a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197
198mueeZHGen::mueeZHGen(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
199: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
200{
201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
202 throw std::runtime_error("mueeZHGen called with a class whose parent is not NPbase");
203}
204
206{
208}
209
210
211mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
212: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
213{
214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
215 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
216}
217
219{
221}
222
223mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
225{
226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
227 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
228}
229
231{
233}
234
235mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
236: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
237{
238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
239 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
240}
241
243{
245}
246
247mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
249{
250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
251 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
252}
253
255{
257}
258
259mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
260: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
261{
262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
263 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
264}
265
267{
269}
270
271
272aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
273: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
274{
275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
276 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
277}
278
280{
282}
283
284
285bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
286: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
287{
288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
289 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
290}
291
293{
295}
296
297
298muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
299: ThObservable(SM_i), sqrt_s(sqrt_s_i)
300{
301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
302 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
303}
304
306{
307 return myNPbase->muVH(sqrt_s);
308}
309
310muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
312{
313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
314 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
315}
316
318{
319 return myNPbase->muVHpT250(sqrt_s);
320}
321
322muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
323: ThObservable(SM_i), sqrt_s(sqrt_s_i)
324{
325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
326 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
327}
328
330{
331 return myNPbase->muVBFpVH(sqrt_s);
332}
333
334muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
336{
337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
338 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
339}
340
342{
343 return myNPbase->muttH(sqrt_s);
344}
345
346mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
348{
349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
350 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
351}
352
354{
355 return myNPbase->mutHq(sqrt_s);
356}
357
358muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
360{
361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
362 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
363}
364
366{
367 return myNPbase->muggHpttH(sqrt_s);
368}
369
370mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
372{
373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
374 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
375
376}
377
379{
380 return myNPbase->mueettH(sqrt_s);
381}
382
383mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
384: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
385{
386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
387 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
388}
389
391{
393}
394
395mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
397{
398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
399 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
400}
401
403{
404 return myNPbase->mummH(sqrt_s);
405}
406
407mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
409{
410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
411 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
412}
413
415{
416 return myNPbase->mummHNWA(sqrt_s);
417}
418
419// -----------------------------------------------------------------------------
420// Decay widths
421// -----------------------------------------------------------------------------
422
424: ThObservable(SM_i)
425{
426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
427 throw std::runtime_error("GammaHtoggRatio called with a class whose parent is not NPbase");
428}
429
431{
432 return myNPbase->GammaHggRatio();
433}
434
436: ThObservable(SM_i)
437{
438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
439 throw std::runtime_error("GammaHtoWWRatio called with a class whose parent is not NPbase");
440}
441
443{
444 return myNPbase->GammaHWWRatio();
445}
446
448: ThObservable(SM_i)
449{
450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
451 throw std::runtime_error("GammaHtoZZRatio called with a class whose parent is not NPbase");
452}
453
455{
456 return myNPbase->GammaHZZRatio();
457}
458
460{
461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
462 throw std::runtime_error("GammaHtoZgaRatio called with a class whose parent is not NPbase");
463}
464
466{
467 return myNPbase->GammaHZgaRatio();
468}
469
471{
472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
473 throw std::runtime_error("GammaHtogagaRatio called with a class whose parent is not NPbase");
474}
475
477{
478 return myNPbase->GammaHgagaRatio();
479}
480
482{
483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
484 throw std::runtime_error("GammaHtomumuRatio called with a class whose parent is not NPbase");
485}
486
488{
489 return myNPbase->GammaHmumuRatio();
490}
491
493{
494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
495 throw std::runtime_error("GammaHtotautauRatio called with a class whose parent is not NPbase");
496}
497
499{
500 return myNPbase->GammaHtautauRatio();
501}
502
504{
505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
506 throw std::runtime_error("GammaHtossRatio called with a class whose parent is not NPbase");
507}
508
510{
511 return myNPbase->GammaHssRatio();
512}
513
515{
516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
517 throw std::runtime_error("GammaHtoccRatio called with a class whose parent is not NPbase");
518}
519
521{
522 return myNPbase->GammaHccRatio();
523}
524
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("GammaHtobbRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->GammaHbbRatio();
534}
535
537: ThObservable(SM_i)
538{
539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
540 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
541}
542
544{
546}
547
548// -----------------------------------------------------------------------------
549// Branching Ratios
550// -----------------------------------------------------------------------------
551
553{
554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
555 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
556}
557
559{
560 return myNPbase->BrHtoinvRatio();
561}
562
564: ThObservable(SM_i)
565{
566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
567 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
568}
569
571{
572 return myNPbase->Br_H_inv();
573}
574
576: ThObservable(SM_i)
577{
578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
579 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
580}
581
583{
584 return myNPbase->Br_H_inv_NP();
585}
586
588: ThObservable(SM_i)
589{
590 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
591 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
592}
593
595{
596 return myNPbase->Br_H_exo();
597}
598
600: ThObservable(SM_i)
601{
602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
603 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
604}
605
607{
608 return myNPbase->BrHvisRatio();
609}
610
612: ThObservable(SM_i)
613{
614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
615 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
616}
617
619{
620 return myNPbase->BrHggRatio();
621}
622
624: ThObservable(SM_i)
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHWWRatio();
633}
634
636: ThObservable(SM_i)
637{
638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
639 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
640}
641
643{
644 return myNPbase->BrHZZRatio();
645}
646
648: ThObservable(SM_i)
649{
650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
651 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
652}
653
655{
656 return myNPbase->BrHVVRatio();
657}
658
660{
661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
662 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
663}
664
666{
667 return myNPbase->BrHZgaRatio();
668}
669
671{
672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
673 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
674}
675
677{
678 return myNPbase->BrHZgallRatio();
679}
680
682{
683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
684 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
685}
686
688{
689 return myNPbase->BrHZgaeeRatio();
690}
691
693{
694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
695 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
696}
697
699{
700 return myNPbase->BrHZgamumuRatio();
701}
702
704{
705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
706 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
707}
708
710{
711 return myNPbase->BrHgagaRatio();
712}
713
715{
716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
717 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
718}
719
721{
722 return myNPbase->BrHmumuRatio();
723}
724
726{
727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
728 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
729}
730
732{
733 return myNPbase->BrHtautauRatio();
734}
735
737{
738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
739 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
740}
741
743{
744 return myNPbase->BrHccRatio();
745}
746
748{
749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
750 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
751}
752
754{
755 return myNPbase->BrHbbRatio();
756}
757
758// -----------------------------------------------------------------------------
759// More 4 fermion decays
760// -----------------------------------------------------------------------------
761
762
764: ThObservable(SM_i)
765{
766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
767 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
768}
769
771{
772 return myNPbase->BrH2l2vRatio();
773}
774
775
777: ThObservable(SM_i)
778{
779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
780 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
781}
782
784{
785 return myNPbase->BrHevmuvRatio();
786}
787
788
790: ThObservable(SM_i)
791{
792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
793 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
794}
795
797{
798 // SM decay widths (from MG simulations)
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
800
801 // Sum
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
803
804 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
805}
806
807
809: ThObservable(SM_i)
810{
811 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
812 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
813}
814
816{
817 // SM decay widths (from MG simulations)
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
819
820 // Sum
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
822
823 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
824}
825
826
828: ThObservable(SM_i)
829{
830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
831 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
832}
833
835{
836 return myNPbase->BrH4lRatio();
837}
838
839
841: ThObservable(SM_i)
842{
843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
844 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
845}
846
848{
849 return myNPbase->BrH4eRatio();
850}
851
852
854: ThObservable(SM_i)
855{
856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
857 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
858}
859
861{
862 return myNPbase->BrH4muRatio();
863}
864
865
867: ThObservable(SM_i)
868{
869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
870 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
871}
872
874{
875 return myNPbase->BrH2e2muRatio();
876}
877
878
879
881: ThObservable(SM_i)
882{
883 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
884 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
885}
886
888{
889 return myNPbase->BrHlljjRatio();
890}
891
892
894: ThObservable(SM_i)
895{
896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
897 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
898}
899
901{
902 return myNPbase->BrHlvjjRatio();
903}
904
905
907: ThObservable(SM_i)
908{
909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
910 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
911}
912
914{
915 return myNPbase->BrHlv_lvorjjRatio();
916}
917
918
920: ThObservable(SM_i)
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
924}
925
927{
928 return myNPbase->BrHll_vvorjjRatio();
929}
930
931// -----------------------------------------------------------------------------
932// Ratios of BR (ratios with SM)
933// -----------------------------------------------------------------------------
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
945 } else {
946 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
960 } else {
961 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
975 } else {
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHtoZga_over_4mu_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4muRatio()));
990 } else {
991 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4muRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtoZmumuga_over_4mu_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrH4muRatio()));
1005 } else {
1006 return (myNPbase->BrHZgamumuRatio()) / (myNPbase->BrH4muRatio());
1007 }
1008}
1009
1011{
1012 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1013 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
1014}
1015
1017{
1018 if ((this->getModel()).isModelLinearized()) {
1019 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
1020 } else {
1021 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
1022 }
1023}
1024
1026{
1027 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1028 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
1029}
1030
1032{
1033 if ((this->getModel()).isModelLinearized()) {
1034 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
1035 } else {
1036 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
1037 }
1038}
1039
1040
1042{
1043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1044 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1045}
1046
1048{
1049 if ((this->getModel()).isModelLinearized()) {
1050 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
1051 } else {
1052 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
1053 }
1054}
1055
1056
1058{
1059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1060 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1061}
1062
1064{
1065 if ((this->getModel()).isModelLinearized()) {
1066 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
1067 } else {
1068 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
1069 }
1070}
1071
1072
1074{
1075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1076 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1077}
1078
1080{
1081 if ((this->getModel()).isModelLinearized()) {
1082 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
1083 } else {
1084 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
1085 }
1086}
1087
1089{
1090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1091 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1092}
1093
1095{
1096 if ((this->getModel()).isModelLinearized()) {
1097 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
1098 } else {
1099 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
1100 }
1101}
1102
1104{
1105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1106 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1107}
1108
1110{
1111 if ((this->getModel()).isModelLinearized()) {
1112 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
1113 } else {
1114 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
1115 }
1116}
1117
1119{
1120 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1121 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1122}
1123
1125{
1126 if ((this->getModel()).isModelLinearized()) {
1127 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
1128 } else {
1129 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
1130 }
1131}
1132
1134{
1135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1136 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1137}
1138
1140{
1141 if ((this->getModel()).isModelLinearized()) {
1142 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
1143 } else {
1144 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
1145 }
1146}
1147
1149{
1150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1151 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1152}
1153
1155{
1156 if ((this->getModel()).isModelLinearized()) {
1157 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1158 } else {
1159 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1160 }
1161}
1162
1164{
1165 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1166 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1167}
1168
1170{
1171 if ((this->getModel()).isModelLinearized()) {
1172 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1173 } else {
1174 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1175 }
1176}
1177
1178
1180{
1181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1182 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1183}
1184
1186{
1187 if ((this->getModel()).isModelLinearized()) {
1188 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1189 } else {
1190 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1191 }
1192}
1193
1194
1196{
1197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1198 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1199}
1200
1202{
1203 if ((this->getModel()).isModelLinearized()) {
1204 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1205 } else {
1206 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1207 }
1208}
1209
1210
1212{
1213 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1214 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1215}
1216
1218{
1219 if ((this->getModel()).isModelLinearized()) {
1220 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1221 } else {
1222 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1223 }
1224}
1225
1226
1228{
1229 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1230 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1231}
1232
1234{
1235 if ((this->getModel()).isModelLinearized()) {
1236 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1237 } else {
1238 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1239 }
1240}
1241
1242
1244{
1245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1246 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1247}
1248
1250{
1251 if ((this->getModel()).isModelLinearized()) {
1252 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1253 } else {
1254 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1255 }
1256}
1257
1258
1259// -----------------------------------------------------------------------------
1260// Full signal strengths (prod x decay)
1261// -----------------------------------------------------------------------------
1262
1263muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1264: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1265{
1266 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1267 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1268}
1269
1271{
1272 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1273 //AG: Most general expression including quadratic corrections.
1274 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1275 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1276 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1277 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1278 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1279 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1280
1281 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1282 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1283 double Br1 = dGammaR1-dGammaRTot1;
1284 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1285 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1286 } else {
1287 return myNPbase->muggHgaga(sqrt_s);
1288 }
1289}
1290
1291muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1292: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1293{
1294 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1295 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1296}
1297
1299{
1301}
1302
1303muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1304: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1305{
1306 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1307 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1308}
1309
1311{
1312 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1313 //AG: Most general expression including quadratic corrections.
1314 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1315 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1316 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1317 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1318 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1319 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1320
1321 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1322 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1323 double Br1 = dGammaR1-dGammaRTot1;
1324 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1325
1326 double mu;
1327
1328 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1329
1330 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1331
1332 return mu;
1333 } else {
1334 return myNPbase->muVBFHgaga(sqrt_s);
1335 }
1336}
1337
1338muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1340{
1341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1342 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1343}
1344
1346{
1347 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1348 //AG: Most general expression including quadratic corrections.
1349 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1350 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1351 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1352 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1353 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1354 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1355
1356 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1357 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1358 double Br1 = dGammaR1-dGammaRTot1;
1359 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1360
1361 double mu;
1362
1363 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1364
1365 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1366
1367 return mu;
1368
1369 } else {
1370 return myNPbase->muZHgaga(sqrt_s);
1371 }
1372}
1373
1374muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1375: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1376{
1377 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1378 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1379}
1380
1382{
1383 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1384 //AG: Most general expression including quadratic corrections.
1385 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1386 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1387 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1388 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1389 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1390 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1391
1392 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1393 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1394 double Br1 = dGammaR1-dGammaRTot1;
1395 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1396
1397 double mu;
1398
1399 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1400
1401 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1402
1403 return mu;
1404
1405 } else {
1406 return myNPbase->muWHgaga(sqrt_s);
1407 }
1408}
1409
1410muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1411: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1412{
1413 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1414 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1415}
1416
1418{
1419 if ((this->getModel()).isModelLinearized()) {
1420 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1421 } else {
1422 return myNPbase->muVHgaga(sqrt_s);
1423 }
1424}
1425
1426muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1427: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1428{
1429 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1430 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1431}
1432
1434{
1435 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1436 //AG: Most general expression including quadratic corrections.
1437 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1438 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1439 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1440 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1441 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1442 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1443
1444 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1445 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1446 double Br1 = dGammaR1-dGammaRTot1;
1447 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1448
1449 double mu;
1450
1451 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1452
1453 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1454
1455 return mu;
1456
1457 } else {
1458 return myNPbase->muttHgaga(sqrt_s);
1459 }
1460}
1461
1462mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1463: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1464{
1465 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1466 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1467}
1468
1470{
1471 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1472 //AG: Most general expression including quadratic corrections.
1473 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1474 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1475 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1476 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1477 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1478
1479 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1480 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1481 double Br1 = dGammaR1-dGammaRTot1;
1482 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1483
1484 double mu;
1485
1486 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1487
1488 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1489
1490 return mu;
1491
1492 } else {
1493 //VM: Just in case someone wants to add directly the production*decay
1494 //(which is the observable we fit at the end)
1495 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1496 if(NPmutHgaga==1.0){
1497 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1498 } else{
1499 return NPmutHgaga;
1500 }
1501 }
1502}
1503
1504muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1505: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1506{
1507 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1508 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1509}
1510
1512{
1513 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1514 //AG: Most general expression including quadratic corrections.
1515 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1516 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1517 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1518 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1519 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1520
1521 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1522 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1523 double Br1 = dGammaR1-dGammaRTot1;
1524 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1525
1526 double mu;
1527
1528 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1529
1530 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1531
1532 return mu;
1533
1534 } else {
1535 //VM: Just in case someone wants to add directly the production*decay
1536 //(which is the observable we fit at the end)
1537 //Also, the bbH is missing here, I'll leave it as it was for the
1538 //moment (since bbH is really suppressed).
1539 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1540 if (NPmuggHpbbH_Hgaga == 1.0){
1541 return (myNPbase->muggHgaga(sqrt_s));
1542 } else{
1543 return NPmuggHpbbH_Hgaga;
1544 }
1545 }
1546}
1547
1548muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1549: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1550{
1551 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1552 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1553}
1554
1556{
1557 //VM:Note that these values are valid for 13 TeV, they are not general
1558 //We should access the SM function that has all the values (for the
1559 //different energies). The values are slightly different, we should
1560 //check this.
1561 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1562 double xsSM_ttH = 0.499873;
1563 double xsSM_tH = 0.0821;
1564 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1565 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1566
1567 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1568 //AG: Most general expression including quadratic corrections.
1569 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1570 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1571 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1572 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1573 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1574
1575 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1576 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1577 double Br1 = dGammaR1-dGammaRTot1;
1578 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1579
1580 double mu;
1581
1582 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1583
1584 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1585
1586 return mu;
1587
1588 } else {
1589 //VM: Just in case someone wants to add directly the production*decay
1590 //(which is the observable we fit at the end)
1591 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1592 if(NPmuttHptH_Hgaga==1.0){
1593 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1594 } else {
1595 return NPmuttHptH_Hgaga;
1596 }
1597 }
1598}
1599
1600muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1601: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1602{
1603 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1604 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1605}
1606
1608{
1609 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1610 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1611 //AG: Most general expression including quadratic corrections.
1612 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1613 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1614 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1615 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1616 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1617
1618 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1619 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1620 double Br1 = dGammaR1-dGammaRTot1;
1621 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1622
1623 double mu;
1624
1625 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1626
1627 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1628
1629 return mu;
1630
1631 } else {
1632 return myNPbase->muggHZga(sqrt_s);
1633 }
1634}
1635
1636muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1637: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1638{
1639 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1640 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1641}
1642
1644{
1645 if ((this->getModel()).isModelLinearized()) {
1646 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1647 } else {
1649 }
1650}
1651
1652muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1653: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1654{
1655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1656 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1657}
1658
1660{
1661 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1662 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1663 //AG: Most general expression including quadratic corrections.
1664 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1665 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1666 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1667 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1668 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1669
1670 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1671 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1672 double Br1 = dGammaR1-dGammaRTot1;
1673 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1674
1675 double mu;
1676
1677 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1678
1679 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1680
1681 return mu;
1682
1683 } else {
1684 return myNPbase->muVBFHZga(sqrt_s);
1685 }
1686}
1687
1688muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1689: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1690{
1691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1692 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1693}
1694
1696{
1697 if ((this->getModel()).isModelLinearized()) {
1698 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1699 } else {
1700 return myNPbase->muZHZga(sqrt_s);
1701 }
1702}
1703
1704muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1705: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1706{
1707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1708 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1709}
1710
1712{
1713 if ((this->getModel()).isModelLinearized()) {
1714 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1715 } else {
1716 return myNPbase->muWHZga(sqrt_s);
1717 }
1718}
1719
1720muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1721: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1722{
1723 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1724 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1725}
1726
1728{
1729 if ((this->getModel()).isModelLinearized()) {
1730 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1731 } else {
1732 return myNPbase->muVHZga(sqrt_s);
1733 }
1734}
1735
1736muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1737: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1738{
1739 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1740 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1741}
1742
1744{
1745 if ((this->getModel()).isModelLinearized()) {
1746 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1747 } else {
1748 return myNPbase->muttHZga(sqrt_s);
1749 }
1750}
1751
1752
1753
1754
1755
1756muggHpttHptHpbbH_HZga::muggHpttHptHpbbH_HZga(const StandardModel& SM_i, const double sqrt_s_i) //VM:added
1757: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1758{
1759 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1760 throw std::runtime_error("muggHpttHptHpbbH_HZga called with a class whose parent is not NPbase");
1761}
1762
1764{
1765 //VM:Note that these values are valid for 13 TeV, they are not general
1766 //We should access the SM function that has all the values (for the
1767 //different energies). The values are slightly different, we should
1768 //check this. Furthermore, the bbH is not included. In the SM this is
1769 //very suppressed (and it's probably also the case in the SMEFT) but
1770 //in some NP models it may not be the case.Unfortunately, bbH is not
1771 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
1772 //SMEFT and add here the general expression.
1773 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1774 double xsSM_ggHbbH = 44.745;
1775 double xsSM_ttH = 0.4998;
1776 double xsSM_tH = 0.084769;
1777 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
1778 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1779 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
1780 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
1781
1782
1783
1784 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1785 //AG: Most general expression including quadratic corrections.
1786 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1787 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
1788 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
1789 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1790 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1791
1792 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1793 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1794 double Br1 = dGammaR1-dGammaRTot1;
1795 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1796
1797 double mu;
1798
1799 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1800
1801 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1802
1803 return mu;
1804
1805 } else {
1806
1807 //VM: Just in case someone wants to add directly the production*decay
1808 //(which is the observable we fit at the end). Furthermore, the Hbb
1809 //is not added in the original formula, fine for the SM (probably also
1810 //for the SMEFT) but not for all NP models.
1811 double NPmuggHpttHptHpbbH_HZga = myNPbase->muggHpttHptHpbbH_HZga(sqrt_s);
1812 if(NPmuggHpttHptHpbbH_HZga==1.0){
1813 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHZgaRatio()) ;
1814 } else {
1815 return NPmuggHpttHptHpbbH_HZga;
1816 }
1817 }
1818}
1819
1820
1821muVBFpVH_HZga::muVBFpVH_HZga(const StandardModel& SM_i, const double sqrt_s_i) //VM:added
1822: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1823{
1824 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1825 throw std::runtime_error("muVBFpVH_HZga called with a class whose parent is not NPbase");
1826}
1827
1829{
1830
1831 //VM:Note that these values are valid for 13 TeV, they are not general
1832 //We should access the SM function that has all the values (for the
1833 //different energies). The values are slightly different, we should
1834 //check this.
1835 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1836 double xsSM_VBF = 3.49948;
1837 double xsSM_WH = 1.21539;
1838 double xsSM_ZH = 0.795910;
1839 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
1840 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1841 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1842 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1843 //AG: Most general expression including quadratic corrections.
1844 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1845 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
1846 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
1847 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1848 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1849
1850 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1851 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1852 double Br1 = dGammaR1-dGammaRTot1;
1853 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1854
1855 double mu;
1856
1857 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1858
1859 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1860
1861 return mu;
1862
1863 } else {
1864
1865 //VM: Just in case someone wants to add directly the production*decay
1866 //(which is the observable we fit at the end).
1867 double NPmuVBFpVH_HZga = myNPbase->muVBFpVH_HZga(sqrt_s);
1868 if(NPmuVBFpVH_HZga==1.0){
1869 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHZgaRatio()) ;
1870 } else {
1871 return NPmuVBFpVH_HZga;
1872 }
1873 }
1874}
1875
1876
1877
1878
1879
1880
1881muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1882: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1883{
1884 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1885 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1886}
1887
1889{
1890 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1891 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1892 //AG: Most general expression including quadratic corrections.
1893 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1894 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1895 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1896 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1897 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1898
1899 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1900 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1901 double Br1 = dGammaR1-dGammaRTot1;
1902 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1903
1904 double mu;
1905
1906 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1907
1908 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1909
1910 return mu;
1911
1912 } else {
1913 return myNPbase->muggHZZ(sqrt_s);
1914 }
1915}
1916
1917muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1918: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1919{
1920 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1921 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1922}
1923
1925{
1926 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1927 //AG: Most general expression including quadratic corrections.
1928 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1929 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1930 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1931 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1932 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1933 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1934
1935 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1936 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1937 double Br1 = dGammaR1-dGammaRTot1;
1938 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1939
1940 double mu;
1941
1942 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1943
1944 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1945
1946 return mu;
1947
1948 } else {
1949 return myNPbase->muVBFHZZ(sqrt_s);
1950 }
1951}
1952
1953muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1954: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1955{
1956 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1957 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1958}
1959
1961{
1962 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1963 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1964 //AG: Most general expression including quadratic corrections.
1965 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1966 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1967 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1968 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1969 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1970
1971 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1972 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1973 double Br1 = dGammaR1-dGammaRTot1;
1974 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1975
1976 double mu;
1977
1978 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1979
1980 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1981
1982 return mu;
1983
1984 } else {
1985 return myNPbase->muZHZZ(sqrt_s);
1986 }
1987}
1988
1989muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1990: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1991{
1992 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1993 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1994}
1995
1997{
1998 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1999 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
2000 //AG: Most general expression including quadratic corrections.
2001 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2002 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2003 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2004 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2005 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2006
2007 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2008 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2009 double Br1 = dGammaR1-dGammaRTot1;
2010 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2011
2012 double mu;
2013
2014 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2015
2016 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2017
2018 return mu;
2019
2020 } else {
2021 return myNPbase->muWHZZ(sqrt_s);
2022 }
2023}
2024
2025muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
2026: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2027{
2028 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2029 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
2030}
2031
2033{
2034 //VM:Note that these values are valid for 13 TeV, they are not general
2035 //We should access the SM function that has all the values (for the
2036 //different energies). The values are slightly different, we should
2037 //check this.
2038 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2039 double xsSM_WH = 1.21539;
2040 double xsSM_ZH = 0.795910;
2041 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2042 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2043 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2044 //AG: Most general expression including quadratic corrections.
2045 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2046 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
2047 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2048 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2049 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2050 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2051
2052 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2053 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2054 double Br1 = dGammaR1-dGammaRTot1;
2055 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2056
2057 double mu;
2058
2059 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2060
2061 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2062
2063 return mu;
2064
2065 } else {
2066 //return myNPbase->muVHZZ(sqrt_s);
2067 //VM: Just in case someone wants to add directly the production*decay
2068 //(which is the observable we fit at the end)
2069 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
2070 if(NPmuVHZZ==1.0){
2071 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
2072 } else {
2073 return NPmuVHZZ;
2074 }
2075 }
2076}
2077
2078muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
2079: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2080{
2081 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2082 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
2083}
2084
2086{
2087 if ((this->getModel()).isModelLinearized()) {
2088 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
2089 } else {
2090 return myNPbase->muttHZZ(sqrt_s);
2091 }
2092}
2093
2094muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2095: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2096{
2097 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2098 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
2099}
2100
2102{
2103 //VM:Note that these values are valid for 13 TeV, they are not general
2104 //We should access the SM function that has all the values (for the
2105 //different energies). The values are slightly different, we should
2106 //check this.
2107 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2108 double xsSM_ttH = 0.499873;
2109 double xsSM_tH = 0.0821;
2110 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2111 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2112 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2113 //AG: Most general expression including quadratic corrections.
2114 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2115 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
2116 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2117 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2118 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2119 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2120
2121 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2122 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2123 double Br1 = dGammaR1-dGammaRTot1;
2124 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2125
2126 double mu;
2127
2128 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2129
2130 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2131
2132 return mu;
2133
2134 } else {
2135
2136 //VM: Just in case someone wants to add directly the production*decay
2137 //(which is the observable we fit at the end)
2138 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
2139 if(NPmuttHptH_HZZ==1.0){
2140 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
2141 } else {
2142 return NPmuttHptH_HZZ;
2143 }
2144 }
2145}
2146
2147muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
2148: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2149{
2150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2151 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
2152}
2153
2155{
2156 //VM:Note that these values are valid for 13 TeV, they are not general
2157 //We should access the SM function that has all the values (for the
2158 //different energies). The values are slightly different, we should
2159 //check this.
2160 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2161 double xsSM_ttH = 0.499873;
2162 double xsSM_tH = 0.0821;
2163 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2164 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2165 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2166 //return ( 1.0
2167 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
2168 // + (myNPbase->BrHmumuRatio()-1.));
2169 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
2170 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2171 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2172 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2173
2174 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2175 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2176 double Br1 = dGammaR1-dGammaRTot1;
2177 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2178
2179 double mu;
2180
2181 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2182
2183 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2184
2185 return mu;
2186
2187 } else {
2188
2189 //VM: Just in case someone wants to add directly the production*decay
2190 //(which is the observable we fit at the end)
2191 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
2192 if(NPmuttHptH_Hmumu==1.0){
2193 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
2194 } else {
2195 return NPmuttHptH_Hmumu;
2196 }
2197 }
2198}
2199
2200muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2201: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2202{
2203 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2204 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
2205}
2206
2208{
2209 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2210 //AG: Most general expression including quadratic corrections.
2211 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2212 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
2213 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2214 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2215 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2216 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2217
2218 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2219 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2220 double Br1 = dGammaR1-dGammaRTot1;
2221 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2222
2223 double mu;
2224
2225 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2226
2227 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2228
2229 return mu;
2230
2231 } else {
2232 //VM: Just in case someone wants to add directly the production*decay
2233 //(which is the observable we fit at the end)
2234 //Also, the bbH is missing here, I'll leave it as it was for the
2235 //moment (since bbH is really suppressed in the SM).
2236 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
2237 if (NPmuggHpbbH_HZZ == 1.0){
2238 return (myNPbase->muggHZZ(sqrt_s));
2239 } else{
2240 return NPmuggHpbbH_HZZ;
2241 }
2242 }
2243}
2244
2245muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2246: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2247{
2248 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2249 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
2250}
2251
2253{
2254 if ((this->getModel()).isModelLinearized()) {
2255 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2256 } else {
2257 return myNPbase->muggHZZ4l(sqrt_s);
2258 }
2259}
2260
2261muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
2262: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2263{
2264 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2265 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
2266}
2267
2269{
2270 if ((this->getModel()).isModelLinearized()) {
2271 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
2272 } else {
2273 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
2274 }
2275}
2276
2277muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2278: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2279{
2280 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2281 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2282}
2283
2285{
2286 if ((this->getModel()).isModelLinearized()) {
2287 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2288 } else {
2289 return myNPbase->muVBFHZZ4l(sqrt_s);
2290 }
2291}
2292
2293muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2294: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2295{
2296 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2297 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2298}
2299
2301{
2302 if ((this->getModel()).isModelLinearized()) {
2303 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2304 } else {
2305 return myNPbase->muZHZZ4l(sqrt_s);
2306 }
2307}
2308
2309muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2310: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2311{
2312 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2313 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2314}
2315
2317{
2318 if ((this->getModel()).isModelLinearized()) {
2319 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2320 } else {
2321 return myNPbase->muWHZZ4l(sqrt_s);
2322 }
2323}
2324
2325muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2326: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2327{
2328 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2329 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2330}
2331
2333{
2334 if ((this->getModel()).isModelLinearized()) {
2335 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2336 } else {
2337 return myNPbase->muVHZZ4l(sqrt_s);
2338 }
2339}
2340
2341muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2342: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2343{
2344 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2345 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2346}
2347
2349{
2350 if ((this->getModel()).isModelLinearized()) {
2351 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2352 } else {
2353 return myNPbase->muttHZZ4l(sqrt_s);
2354 }
2355}
2356
2357muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2358: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2359{
2360 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2361 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2362}
2363
2365{
2366 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2367 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2368 //AG: Most general expression including quadratic corrections.
2369 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2370 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2371 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2372 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2373 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2374
2375 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2376 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2377 double Br1 = dGammaR1-dGammaRTot1;
2378 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2379
2380 double mu;
2381
2382 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2383
2384 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2385
2386 return mu;
2387
2388 } else {
2389 return myNPbase->muggHWW(sqrt_s);
2390 }
2391}
2392
2393muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2394: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2395{
2396 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2397 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2398}
2399
2401{
2402 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2403 //AG: Most general expression including quadratic corrections.
2404 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2405 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2406 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2407 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2408 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2409 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2410
2411 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2412 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2413 double Br1 = dGammaR1-dGammaRTot1;
2414 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2415
2416 double mu;
2417
2418 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2419
2420 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2421
2422 return mu;
2423
2424 } else {
2425 return myNPbase->muVBFHWW(sqrt_s);
2426 }
2427}
2428
2429muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2430: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2431{
2432 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2433 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2434}
2435
2437{
2438 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2439 //AG: Most general expression including quadratic corrections.
2440 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2441 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2442 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2443 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2444 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2445 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2446
2447 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2448 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2449 double Br1 = dGammaR1-dGammaRTot1;
2450 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2451
2452 double mu;
2453
2454 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2455
2456 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2457
2458 return mu;
2459
2460 } else {
2461 return myNPbase->muZHWW(sqrt_s);
2462 }
2463}
2464
2465muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2466: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2467{
2468 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2469 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2470}
2471
2473{
2474 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2475 //AG: Most general expression including quadratic corrections.
2476 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2477 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2478 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2479 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2480 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2481 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2482
2483 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2484 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2485 double Br1 = dGammaR1-dGammaRTot1;
2486 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2487
2488 double mu;
2489
2490 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2491
2492 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2493
2494 return mu;
2495
2496 } else {
2497 return myNPbase->muWHWW(sqrt_s);
2498 }
2499}
2500
2501muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2502: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2503{
2504 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2505 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2506}
2507
2509{
2510 if ((this->getModel()).isModelLinearized()) {
2511 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2512 } else {
2513 return myNPbase->muVHWW(sqrt_s);
2514 }
2515}
2516
2517muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2518: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2519{
2520 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2521 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2522}
2523
2525{
2526 if ((this->getModel()).isModelLinearized()) {
2527 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2528 } else {
2529 return myNPbase->muttHWW(sqrt_s);
2530 }
2531}
2532
2533muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2534: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2535{
2536 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2537 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2538}
2539
2541{
2542
2543 //VM:Note that these values are valid for 13 TeV, they are not general
2544 //We should access the SM function that has all the values (for the
2545 //different energies). The values are slightly different, we should
2546 //check this.
2547 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2548 double xsSM_ttH = 0.499873;
2549 double xsSM_tH = 0.0821;
2550 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2551 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2552 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2553 //AG: Most general expression including quadratic corrections.
2554 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2555 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2556 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2557 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2558 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2559
2560 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2561 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2562 double Br1 = dGammaR1-dGammaRTot1;
2563 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2564
2565 double mu;
2566
2567 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2568
2569 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2570
2571 return mu;
2572
2573 } else {
2574
2575 //VM: Just in case someone wants to add directly the production*decay
2576 //(which is the observable we fit at the end)
2577 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2578 if(NPmuttHptH_HWW==1.0){
2579 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2580 } else {
2581 return NPmuttHptH_HWW;
2582 }
2583 }
2584}
2585
2586muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2587: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2588{
2589 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2590 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2591}
2592
2594{
2595 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2596 //AG: Most general expression including quadratic corrections.
2597 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2598 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2599 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2600 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2601 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2602 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2603
2604 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2605 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2606 double Br1 = dGammaR1-dGammaRTot1;
2607 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2608
2609 double mu;
2610
2611 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2612
2613 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2614
2615 return mu;
2616
2617 } else {
2618
2619 //VM: Just in case someone wants to add directly the production*decay
2620 //(which is the observable we fit at the end)
2621 //Also, the bbH is missing here, I'll leave it as it was for the
2622 //moment (since bbH is really suppressed in the SM).
2623 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2624 if (NPmuggHpbbH_HWW == 1.0){
2625 return (myNPbase->muggHWW(sqrt_s));
2626 } else{
2627 return NPmuggHpbbH_HWW;
2628 }
2629 }
2630}
2631
2632muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2633: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2634{
2635 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2636 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2637}
2638
2640{
2641 if ((this->getModel()).isModelLinearized()) {
2642 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2643 } else {
2644 return myNPbase->muggHWW2l2v(sqrt_s);
2645 }
2646}
2647
2648muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2649: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2650{
2651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2652 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2653}
2654
2656{
2657 if ((this->getModel()).isModelLinearized()) {
2658 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2659 } else {
2660 return myNPbase->muVBFHWW2l2v(sqrt_s);
2661 }
2662}
2663
2664muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2665: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2666{
2667 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2668 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2669}
2670
2672{
2673 if ((this->getModel()).isModelLinearized()) {
2674 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2675 } else {
2676 return myNPbase->muZHWW2l2v(sqrt_s);
2677 }
2678}
2679
2680muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2681: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2682{
2683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2684 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2685}
2686
2688{
2689 if ((this->getModel()).isModelLinearized()) {
2690 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2691 } else {
2692 return myNPbase->muWHWW2l2v(sqrt_s);
2693 }
2694}
2695
2696muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2697: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2698{
2699 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2700 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2701}
2702
2704{
2705 if ((this->getModel()).isModelLinearized()) {
2706 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2707 } else {
2708 return myNPbase->muVHWW2l2v(sqrt_s);
2709 }
2710}
2711
2712muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2713: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2714{
2715 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2716 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2717}
2718
2720{
2721 if ((this->getModel()).isModelLinearized()) {
2722 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2723 } else {
2724 return myNPbase->muttHWW2l2v(sqrt_s);
2725 }
2726}
2727
2728muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2729: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2730{
2731 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2732 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2733}
2734
2736{
2737 if ((this->getModel()).isModelLinearized()) {
2738 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2739 } else {
2740 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2741 }
2742}
2743
2744muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2745: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2746{
2747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2748 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2749}
2750
2752{
2753 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2754 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2755 //AG: Most general expression including quadratic corrections.
2756 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2757 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2758 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2759 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2760 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2761
2762 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2763 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2764 double Br1 = dGammaR1-dGammaRTot1;
2765 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2766
2767 double mu;
2768
2769 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2770
2771 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2772
2773 return mu;
2774
2775 } else {
2776 return myNPbase->muggHmumu(sqrt_s);
2777 }
2778}
2779
2780muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2781: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2782{
2783 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2784 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2785}
2786
2788{
2789 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2790 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2791 //AG: Most general expression including quadratic corrections.
2792 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2793 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2794 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2795 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2796 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2797
2798 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2799 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2800 double Br1 = dGammaR1-dGammaRTot1;
2801 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2802
2803 double mu;
2804
2805 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2806
2807 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2808
2809 return mu;
2810
2811 } else {
2812 return myNPbase->muVBFHmumu(sqrt_s);
2813 }
2814}
2815
2816muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2817: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2818{
2819 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2820 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2821}
2822
2824{
2825 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2826 //AG: Most general expression including quadratic corrections.
2827 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2828 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2829 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2830 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2831 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2832
2833 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2834 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2835 double Br1 = dGammaR1-dGammaRTot1;
2836 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2837
2838 double mu;
2839
2840 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2841
2842 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2843
2844 return mu;
2845
2846 } else {
2847 return myNPbase->muZHmumu(sqrt_s);
2848 }
2849}
2850
2851muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2852: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2853{
2854 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2855 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2856}
2857
2859{
2860 if ((this->getModel()).isModelLinearized()) {
2861 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2862 } else {
2863 return myNPbase->muWHmumu(sqrt_s);
2864 }
2865}
2866
2867muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2868: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2869{
2870 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2871 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2872}
2873
2875{
2876
2877 //VM:Note that these values are valid for 13 TeV, they are not general
2878 //We should access the SM function that has all the values (for the
2879 //different energies). The values are slightly different, we should
2880 //check this.
2881 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2882 double xsSM_WH = 1.21539;
2883 double xsSM_ZH = 0.795910;
2884 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2885 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2886 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2887 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2888 //AG: Most general expression including quadratic corrections.
2889 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2890 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2891 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2892 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2893 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2894
2895 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2896 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2897 double Br1 = dGammaR1-dGammaRTot1;
2898 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2899
2900 double mu;
2901
2902 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2903
2904 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2905
2906 return mu;
2907
2908 } else {
2909 //return myNPbase->muVHmumu(sqrt_s);
2910 //VM: Just in case someone wants to add directly the production*decay
2911 //(which is the observable we fit at the end)
2912 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2913 if(NPmuVHmumu==1.0){
2914 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2915 } else {
2916 return NPmuVHmumu;
2917 }
2918
2919 }
2920}
2921
2922muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2923: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2924{
2925 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2926 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2927}
2928
2930{
2931 if ((this->getModel()).isModelLinearized()) {
2932 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2933 } else {
2934 return myNPbase->muttHmumu(sqrt_s);
2935 }
2936}
2937
2938muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2939: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2940{
2941 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2942 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2943}
2944
2946{
2947 //VM:Note that these values are valid for 13 TeV, they are not general
2948 //We should access the SM function that has all the values (for the
2949 //different energies). The values are slightly different, we should
2950 //check this. Furthermore, the bbH is not included. In the SM this is
2951 //very suppressed (and it's probably also the case in the SMEFT) but
2952 //in some NP models it may not be the case.Unfortunately, bbH is not
2953 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2954 //SMEFT and add here the general expression.
2955 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2956 double xsSM_ggHbbH = 44.745;
2957 double xsSM_ttH = 0.4998;
2958 double xsSM_tH = 0.084769;
2959 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2960 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2961 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2962 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2963
2964
2965
2966 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2967 //AG: Most general expression including quadratic corrections.
2968 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2969 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2970 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2971 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2972 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2973
2974 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2975 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2976 double Br1 = dGammaR1-dGammaRTot1;
2977 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2978
2979 double mu;
2980
2981 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2982
2983 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2984
2985 return mu;
2986
2987 } else {
2988
2989 //VM: Just in case someone wants to add directly the production*decay
2990 //(which is the observable we fit at the end). Furthermore, the Hbb
2991 //is not added in the original formula, fine for the SM (probably also
2992 //for the SMEFT) but not for all NP models.
2993 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2994 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2995 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2996 } else {
2997 return NPmuggHpttHptHpbbH_Hmumu;
2998 }
2999 }
3000}
3001
3002muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3004{
3005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3006 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
3007}
3008
3010{
3011
3012 //VM:Note that these values are valid for 13 TeV, they are not general
3013 //We should access the SM function that has all the values (for the
3014 //different energies). The values are slightly different, we should
3015 //check this.
3016 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3017 double xsSM_VBF = 3.49948;
3018 double xsSM_WH = 1.21539;
3019 double xsSM_ZH = 0.795910;
3020 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3021 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3022 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3023 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3024 //AG: Most general expression including quadratic corrections.
3025 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3026 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
3027 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
3028 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
3029 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
3030
3031 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3032 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3033 double Br1 = dGammaR1-dGammaRTot1;
3034 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3035
3036 double mu;
3037
3038 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3039
3040 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3041
3042 return mu;
3043
3044 } else {
3045
3046 //VM: Just in case someone wants to add directly the production*decay
3047 //(which is the observable we fit at the end).
3048 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
3049 if(NPmuVBFpVH_Hmumu==1.0){
3050 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
3051 } else {
3052 return NPmuVBFpVH_Hmumu;
3053 }
3054 }
3055}
3056
3057muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3058: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3059{
3060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3061 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
3062}
3063
3065{
3066 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3067 //AG: Most general expression including quadratic corrections.
3068 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3069 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3070 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3071 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3072 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3073 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3074
3075 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3076 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3077 double Br1 = dGammaR1-dGammaRTot1;
3078 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3079
3080 double mu;
3081
3082 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3083
3084 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3085
3086 return mu;
3087
3088 } else {
3089 return myNPbase->muggHtautau(sqrt_s);
3090 }
3091}
3092
3093muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3094: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3095{
3096 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3097 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
3098}
3099
3101{
3102 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3103 //AG: Most general expression including quadratic corrections.
3104 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3105 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3106 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
3107 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
3108 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3109 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3110
3111 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3112 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3113 double Br1 = dGammaR1-dGammaRTot1;
3114 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3115
3116 double mu;
3117
3118 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3119
3120 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3121
3122 return mu;
3123
3124 } else {
3125 return myNPbase->muVBFHtautau(sqrt_s);
3126 }
3127}
3128
3129
3130
3131muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3132: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3133{
3134 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3135 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
3136}
3137
3139{
3140 if ((this->getModel()).isModelLinearized()) {
3141 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3142 } else {
3144 }
3145}
3146
3147
3148muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3150{
3151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3152 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
3153}
3154
3155double muZHtautau::computeThValue() //AG:modified
3156{
3157 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3158 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3159 //AG: Most general expression including quadratic corrections.
3160 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3161 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3162 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3163 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3164 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3165 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3166
3167 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3168 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3169 double Br1 = dGammaR1-dGammaRTot1;
3170 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3171
3172 double mu;
3173
3174 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3175
3176 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3177
3178 return mu;
3179
3180 } else {
3181 return myNPbase->muZHtautau(sqrt_s);
3182 }
3183}
3184
3185muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3187{
3188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3189 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
3190}
3191
3193{
3194 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3195 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3196 //AG: Most general expression including quadratic corrections.
3197 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3198 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3199 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3200 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3201 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3202
3203 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3204 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3205 double Br1 = dGammaR1-dGammaRTot1;
3206 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3207
3208 /*std::cout << "muProd1="<<muProd1<<std::endl;
3209 std::cout << "muProd2="<<muProd2<<std::endl;
3210 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
3211 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
3212 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
3213 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
3214
3215 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
3216 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
3217
3218 double mu;
3219
3220 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3221
3222 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3223
3224 return mu;
3225
3226 } else {
3227 return myNPbase->muWHtautau(sqrt_s);
3228 }
3229}
3230
3231muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3232: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3233{
3234 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3235 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
3236}
3237
3239{
3240 //VM:Note that these values are valid for 13 TeV, they are not general
3241 //We should access the SM function that has all the values (for the
3242 //different energies). The values are slightly different, we should
3243 //check this.
3244 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3245 double xsSM_WH = 1.21539;
3246 double xsSM_ZH = 0.795910;
3247 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3248 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3249 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3250 //AG: Most general expression including quadratic corrections.
3251 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3252 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3253 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3254 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3255 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3256 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3257
3258 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3259 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3260 double Br1 = dGammaR1-dGammaRTot1;
3261 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3262
3263 double mu;
3264
3265 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3266
3267 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3268
3269 return mu;
3270
3271 } else {
3272 //return myNPbase->muVHtautau(sqrt_s);
3273
3274 //VM: Just in case someone wants to add directly the production*decay
3275 //(which is the observable we fit at the end)
3276 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
3277 if(NPmuVHtautau==1.0){
3278 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
3279 } else {
3280 return NPmuVHtautau;
3281 }
3282 }
3283}
3284
3285muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3286: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3287{
3288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3289 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3290}
3291
3293{
3294 if ((this->getModel()).isModelLinearized()) {
3295 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3296 } else {
3297 return myNPbase->muttHtautau(sqrt_s);
3298 }
3299}
3300
3301muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3302: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3303{
3304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3305 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3306}
3307
3309{
3310 //VM:Note that these values are valid for 13 TeV, they are not general
3311 //We should access the SM function that has all the values (for the
3312 //different energies). The values are slightly different, we should
3313 //check this.
3314 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3315 double xsSM_ttH = 0.499873;
3316 double xsSM_tH = 0.0821;
3317 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3318 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3319 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3320 //AG: Most general expression including quadratic corrections.
3321 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3322 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3323 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3324 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3325 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3326
3327 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3328 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3329 double Br1 = dGammaR1-dGammaRTot1;
3330 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3331
3332 double mu;
3333
3334 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3335
3336 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3337
3338 return mu;
3339
3340 } else {
3341
3342 //VM: Just in case someone wants to add directly the production*decay
3343 //(which is the observable we fit at the end)
3344 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3345 if(NPmuttHptH_Htautau==1.0){
3346 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3347 } else {
3348 return NPmuttHptH_Htautau;
3349 }
3350
3351 }
3352}
3353
3354muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3355: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3356{
3357 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3358 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3359}
3360
3362{
3363 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3364 //AG: Most general expression including quadratic corrections.
3365 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3366 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3367 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3368 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3369 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3370 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3371
3372 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3373 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3374 double Br1 = dGammaR1-dGammaRTot1;
3375 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3376
3377 double mu;
3378
3379 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3380
3381 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3382
3383 return mu;
3384
3385 } else {
3386
3387 //VM: Just in case someone wants to add directly the production*decay
3388 //(which is the observable we fit at the end)
3389 //Also, the bbH is missing here, I'll leave it as it was for the
3390 //moment (since bbH is really suppressed in the SM).
3391 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3392 if (NPmuggHpbbH_Htautau == 1.0){
3393 return (myNPbase->muggHtautau(sqrt_s));
3394 } else{
3395 return NPmuggHpbbH_Htautau;
3396 }
3397 }
3398}
3399
3400muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3401: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3402{
3403 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3404 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3405}
3406
3408{
3409 if ((this->getModel()).isModelLinearized()) {
3410 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3411 //AG: Most general expression including quadratic corrections.
3412 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3413 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3414 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3415 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3416 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3417
3418 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3419 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3420 double Br1 = dGammaR1-dGammaRTot1;
3421 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3422
3423 double mu;
3424
3425 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3426
3427 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3428
3429 return mu;
3430
3431 } else {
3432 return myNPbase->muggHbb(sqrt_s);
3433 }
3434}
3435
3436muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3437: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3438{
3439 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3440 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3441}
3442
3444{
3445 if ((this->getModel()).isModelLinearized()) {
3446 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3447 } else {
3448 return myNPbase->muVBFHbb(sqrt_s);
3449 }
3450}
3451
3452muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3453: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3454{
3455 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3456 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3457}
3458
3460{
3461 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3462 //AG: Most general expression including quadratic corrections.
3463 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3464 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3465 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3466 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3467 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3468 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3469
3470 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3471 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3472 double Br1 = dGammaR1-dGammaRTot1;
3473 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3474
3475 double mu;
3476
3477 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3478
3479 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3480
3481 return mu;
3482
3483 } else {
3484 return myNPbase->muZHbb(sqrt_s);
3485 }
3486}
3487
3488muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3489: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3490{
3491 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3492 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3493}
3494
3496{
3497 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3498 //AG: Most general expression including quadratic corrections.
3499 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3500 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3501 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3502 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3503 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3504 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3505
3506 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3507 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3508 double Br1 = dGammaR1-dGammaRTot1;
3509 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3510
3511 double mu;
3512
3513 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3514
3515 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3516
3517 return mu;
3518
3519 } else {
3520 return myNPbase->muWHbb(sqrt_s);
3521 }
3522}
3523
3524muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3525: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3526{
3527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3528 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3529}
3530
3532{
3533 if ((this->getModel()).isModelLinearized()) {
3534 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3535 } else {
3536 return myNPbase->muVHbb(sqrt_s);
3537 }
3538}
3539
3540muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3541: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3542{
3543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3544 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3545}
3546
3548{
3549 if ((this->getModel()).isModelLinearized()) {
3550 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3551 } else {
3552 return myNPbase->muttHbb(sqrt_s);
3553 }
3554}
3555
3556muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3557: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3558{
3559 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3560 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3561}
3562
3564{
3565 //VM:Note that these values are valid for 13 TeV, they are not general
3566 //We should access the SM function that has all the values (for the
3567 //different energies). The values are slightly different, we should
3568 //check this.
3569 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3570 double xsSM_ttH = 0.499873;
3571 double xsSM_tH = 0.0821;
3572 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3573 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3574 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3575 //AG: Most general expression including quadratic corrections.
3576 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3577 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3578 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3579 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3580 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3581
3582 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3583 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3584 double Br1 = dGammaR1-dGammaRTot1;
3585 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3586
3587 double mu;
3588
3589 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3590
3591 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3592
3593 return mu;
3594
3595 } else {
3596
3597
3598 //VM: Just in case someone wants to add directly the production*decay
3599 //(which is the observable we fit at the end)
3600 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3601 if(NPmuttHptH_Hbb==1.0){
3602 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3603 } else {
3604 return NPmuttHptH_Hbb;
3605 }
3606 }
3607}
3608
3609muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3610: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3611{
3612 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3613 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3614}
3615
3617{
3618 //VM:Note that these values are valid for 13 TeV, they are not general
3619 //We should access the SM function that has all the values (for the
3620 //different energies). The values are slightly different, we should
3621 //check this. Furthermore, the bbH is not included. In the SM this is
3622 //very suppressed (and it's probably also the case in the SMEFT) but
3623 //in some NP models it may not be the case.Unfortunately, bbH is not
3624 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3625 //SMEFT and add here the general expression.
3626 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3627 double xsSM_ggHbbH = 44.745;
3628 double xsSM_VBF = 3.49948;
3629 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3630 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3631 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3632 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3633 //AG: Most general expression including quadratic corrections.
3634 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3635 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3636 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3637 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3638 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3639
3640 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3641 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3642 double Br1 = dGammaR1-dGammaRTot1;
3643 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3644
3645 double mu;
3646
3647 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3648
3649 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3650
3651 return mu;
3652
3653 } else {
3654
3655
3656 //VM: Just in case someone wants to add directly the production*decay
3657 //(which is the observable we fit at the end). Furthermore, the Hbb
3658 //is not added in the original formula, fine for the SM (probably also
3659 //for the SMEFT) but not for all NP models.
3660 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3661 if(NPmuggHpVBFpbbH_Hbb==1.0){
3662 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3663 } else {
3664 return NPmuggHpVBFpbbH_Hbb;
3665 }
3666 }
3667}
3668
3669
3670
3671muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3672: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3673{
3674 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3675 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3676}
3677
3679{
3680 if ((this->getModel()).isModelLinearized()) {
3681 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3682 } else {
3683 return myNPbase->muVHcc(sqrt_s);
3684 }
3685}
3686
3687
3688muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3689: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3690{
3691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3692 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3693}
3694
3696{
3697
3698 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3699
3700}
3701
3702muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3703: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3704{
3705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3706 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3707}
3708
3710{
3711
3712 if ((this->getModel()).isModelLinearized()) {
3713 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3714 } else {
3715 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3716 }
3717
3718}
3719
3720
3721muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3722: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3723{
3724 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3725 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3726}
3727
3729{
3730
3731 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3732
3733}
3734
3735muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3736: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3737{
3738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3739 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3740}
3741
3743{
3744
3745 if ((this->getModel()).isModelLinearized()) {
3746 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3747 } else {
3748 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3749 }
3750
3751}
3752
3753
3754muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3755: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3756{
3757 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3758 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3759}
3760
3762{
3763 return myNPbase->muppHmumu(sqrt_s);
3764}
3765
3766muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3767: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3768{
3769 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3770 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3771}
3772
3774{
3775 return myNPbase->muppHZga(sqrt_s);
3776}
3777
3778muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3779: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3780{
3781 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3782 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3783}
3784
3786{
3787 if ((this->getModel()).isModelLinearized()) {
3788 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3789 } else {
3791 }
3792}
3793
3794muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3795: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3796{
3797 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3798 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3799}
3800
3802{
3803 return (myNPbase->muttHZbbboost(sqrt_s));
3804}
3805
3806muttHgagaZeeboost::muttHgagaZeeboost(const StandardModel& SM_i, const double sqrt_s_i)
3807: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3808{
3809 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3810 throw std::runtime_error("muttHgagaZeeboost called with a class whose parent is not NPbase");
3811}
3812
3814{
3816}
3817
3818//AG:begin
3819ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3820: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3821{
3822 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3823 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3824}
3826{
3827 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3828 if ((this->getModel()).isModelLinearized()) {
3829 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3830 } else {
3831 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3832 }
3833}
3834
3835
3836ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3837: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3838{
3839 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3840 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3841}
3843{
3844 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3845 if ((this->getModel()).isModelLinearized()) {
3846 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3847 } else {
3848 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3849 }
3850}
3851
3852
3853ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3854: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3855{
3856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3857 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3858}
3860{
3861 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3862 if ((this->getModel()).isModelLinearized()) {
3863 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3864 } else {
3865 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3866 }
3867}
3868
3869
3870ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3871: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3872{
3873 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3874 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3875}
3877{
3878 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3879 if ((this->getModel()).isModelLinearized()) {
3880 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3881 } else {
3882 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3883 }
3884}
3885
3886
3887VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3888: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3889{
3890 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3891 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3892}
3894{
3895 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3896 if ((this->getModel()).isModelLinearized()) {
3897 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3898 } else {
3899 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3900 }
3901}
3902
3903
3904VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3905: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3906{
3907 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3908 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3909}
3911{
3912 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3913 if ((this->getModel()).isModelLinearized()) {
3914 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3915 } else {
3916 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3917 }
3918}
3919
3920
3921VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3922: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3923{
3924 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3925 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3926}
3928{
3929 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3930 if ((this->getModel()).isModelLinearized()) {
3931 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3932 } else {
3933 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3934 }
3935}
3936
3937
3938VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3939: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3940{
3941 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3942 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3943}
3945{
3946 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3947 if ((this->getModel()).isModelLinearized()) {
3948 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3949 } else {
3950 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3951 }
3952}
3953
3954
3955WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3956: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3957{
3958 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3959 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3960}
3962{
3963 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3964 if ((this->getModel()).isModelLinearized()) {
3965 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3966 } else {
3967 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3968 }
3969}
3970
3971
3972WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3973: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3974{
3975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3976 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3977}
3979{
3980 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3981 if ((this->getModel()).isModelLinearized()) {
3982 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3983 } else {
3984 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3985 }
3986}
3987
3988
3989WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3990: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3991{
3992 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3993 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3994}
3996{
3997 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3998 if ((this->getModel()).isModelLinearized()) {
3999 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
4000 } else {
4001 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
4002 }
4003}
4004
4005
4006WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
4007: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4008{
4009 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4010 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
4011}
4013{
4014 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4015 if ((this->getModel()).isModelLinearized()) {
4016 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
4017 } else {
4018 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
4019 }
4020}
4021
4022
4023ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
4024: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4025{
4026 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4027 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
4028}
4030{
4031 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4032 if ((this->getModel()).isModelLinearized()) {
4033 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
4034 } else {
4035 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
4036 }
4037}
4038
4039
4040ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
4041: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4042{
4043 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4044 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
4045}
4047{
4048 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4049 if ((this->getModel()).isModelLinearized()) {
4050 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
4051 } else {
4052 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
4053 }
4054}
4055
4056
4057ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4058: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4059{
4060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4061 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
4062}
4064{
4065 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4066 if ((this->getModel()).isModelLinearized()) {
4067 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
4068 } else {
4069 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
4070 }
4071}
4072
4073
4074ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
4075: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4076{
4077 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4078 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
4079}
4081{
4082 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4083 if ((this->getModel()).isModelLinearized()) {
4084 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
4085 } else {
4086 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
4087 }
4088}
4089
4090
4091ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
4092: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4093{
4094 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4095 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
4096}
4098{
4099 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4100 if ((this->getModel()).isModelLinearized()) {
4101 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
4102 } else {
4103 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
4104 }
4105}
4106
4107
4108ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
4109: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4110{
4111 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4112 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
4113}
4115{
4116 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4117 if ((this->getModel()).isModelLinearized()) {
4118 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
4119 } else {
4120 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
4121 }
4122}
4123
4124
4125ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4126: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4127{
4128 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4129 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
4130}
4132{
4133 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4134 if ((this->getModel()).isModelLinearized()) {
4135 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
4136 } else {
4137 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
4138 }
4139}
4140
4141
4142ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
4143: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4144{
4145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4146 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
4147}
4149{
4150 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
4151 if ((this->getModel()).isModelLinearized()) {
4152 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
4153 } else {
4154 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
4155 }
4156}
4157
4158//AG:end
4159
4160UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4161{
4162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4163 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
4164}
4165
4167{
4169}
4170
4171UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4172{
4173 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4174 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4175}
4176
4178{
4180}
4181
4182UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4183{
4184 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4185 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4186}
4187
4189{
4191}
4192
4193UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4194{
4195 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4196 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4197}
4198
4200{
4202}
4203
4205{
4206 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4207 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
4208}
4209
4211{
4212 return myNPbase->cgplusct();
4213}
4214
4216{
4217 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4218 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
4219}
4220
4222{
4223 return myNPbase->cgaplusct();
4224}
4225
4227{
4228 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4229 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
4230}
4231
4233{
4234 return myNPbase->cgminuscga();
4235}
4236
4238{
4239 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4240 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
4241}
4242\
4243
4244
4246{
4247 return myNPbase->cVpluscb();
4248}
4249
4251{
4252 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4253 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
4254}
4255
4257{
4258 return myNPbase->cVplusctau();
4259}
4260
4262{
4263 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4264 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
4265}
4266
4268{
4269 return myNPbase->cbminuscc();
4270}
4271
4273{
4274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4275 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
4276}
4277
4279{
4280 return myNPbase->cbminusctau();
4281}
4282
4284{
4285 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4286 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
4287}
4288
4290{
4291 return myNPbase->ccminusctau();
4292}
4293
4294
4295// Full signal strengths at e+ e- colliders
4296// ----------------------------------------
4297
4298mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4299: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4300{
4301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4302 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4303}
4304
4306{
4307 if ((this->getModel()).isModelLinearized()) {
4309 } else {
4311 }
4312}
4313
4314mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4315: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4316{
4317 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4318 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4319}
4320
4322{
4323 if ((this->getModel()).isModelLinearized()) {
4325 } else {
4327 }
4328}
4329
4330mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4331: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4332{
4333 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4334 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4335}
4336
4338{
4339 if ((this->getModel()).isModelLinearized()) {
4341 } else {
4343 }
4344}
4345
4346mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4347: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4348{
4349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4350 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4351}
4352
4354{
4355 if ((this->getModel()).isModelLinearized()) {
4357 } else {
4359 }
4360}
4361
4362mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4363: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4364{
4365 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4366 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4367}
4368
4370{
4371 if ((this->getModel()).isModelLinearized()) {
4373 } else {
4375 }
4376}
4377
4378mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4379: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4380{
4381 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4382 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4383}
4384
4386{
4387 if ((this->getModel()).isModelLinearized()) {
4389 } else {
4391 }
4392}
4393
4394mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4395: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4396{
4397 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4398 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4399}
4400
4402{
4403 if ((this->getModel()).isModelLinearized()) {
4405 } else {
4407 }
4408}
4409
4410mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4411: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4412{
4413 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4414 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4415}
4416
4418{
4419 if ((this->getModel()).isModelLinearized()) {
4421 } else {
4423 }
4424}
4425
4426mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4427: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4428{
4429 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4430 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4431}
4432
4434{
4435 if ((this->getModel()).isModelLinearized()) {
4437 } else {
4439 }
4440}
4441
4442mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4443: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4444{
4445 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4446 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4447}
4448
4450{
4451 if ((this->getModel()).isModelLinearized()) {
4453 } else {
4455 }
4456}
4457
4458mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4459: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4460{
4461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4462 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4463}
4464
4466{
4467
4469
4470}
4471
4472mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4473: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4474{
4475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4476 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4477}
4478
4480{
4481
4482 if ((this->getModel()).isModelLinearized()) {
4484 } else {
4486 }
4487
4488}
4489
4490mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4491: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4492{
4493 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4494 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4495
4496}
4497
4499{
4500 if ((this->getModel()).isModelLinearized()) {
4502 } else {
4503 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4504 }
4505}
4506
4507mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4508: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4509{
4510 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4511 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4512
4513}
4514
4516{
4517 if ((this->getModel()).isModelLinearized()) {
4519 } else {
4521 }
4522}
4523
4524mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4525: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4526{
4527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4528 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4529
4530}
4531
4533{
4534 if ((this->getModel()).isModelLinearized()) {
4536 } else {
4537 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4538 }
4539}
4540
4541mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4542: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4543{
4544 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4545 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4546
4547}
4548
4550{
4551 if ((this->getModel()).isModelLinearized()) {
4553 } else {
4554 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4555 }
4556}
4557
4558mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4559: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4560{
4561 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4562 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4563
4564}
4565
4567{
4568 if ((this->getModel()).isModelLinearized()) {
4570 } else {
4571 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4572 }
4573}
4574
4575mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4576: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4577{
4578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4579 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4580
4581}
4582
4584{
4585 if ((this->getModel()).isModelLinearized()) {
4587 } else {
4589 }
4590}
4591
4592mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4593: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4594{
4595 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4596 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4597
4598}
4599
4601{
4602 if ((this->getModel()).isModelLinearized()) {
4604 } else {
4605 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4606 }
4607}
4608
4609mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4610: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4611{
4612 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4613 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4614
4615}
4616
4618{
4619 if ((this->getModel()).isModelLinearized()) {
4621 } else {
4622 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4623 }
4624}
4625
4626mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4627: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4628{
4629 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4630 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4631
4632}
4633
4635{
4636 if ((this->getModel()).isModelLinearized()) {
4638 } else {
4640 }
4641}
4642
4643mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4644: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4645{
4646 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4647 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4648
4649}
4650
4652{
4653 if ((this->getModel()).isModelLinearized()) {
4655 } else {
4657 }
4658}
4659
4660mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4661: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4662{
4663 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4664 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4665
4666}
4667
4669{
4670 if ((this->getModel()).isModelLinearized()) {
4672 } else {
4673 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4674 }
4675}
4676
4677mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4678: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4679{
4680 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4681 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4682
4683}
4684
4686{
4687 if ((this->getModel()).isModelLinearized()) {
4689 } else {
4691 }
4692}
4693
4694mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4695: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4696{
4697 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4698 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4699
4700}
4701
4703{
4704 if ((this->getModel()).isModelLinearized()) {
4706 } else {
4707 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4708 }
4709}
4710
4711mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4712: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4713{
4714 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4715 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4716
4717}
4718
4720{
4721 if ((this->getModel()).isModelLinearized()) {
4723 } else {
4725 }
4726}
4727
4728
4729mueeHvvss::mueeHvvss(const StandardModel& SM_i, const double sqrt_s_i)
4730: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4731{
4732 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4733 throw std::runtime_error("mueeHvvss called with a class whose parent is not NPbase");
4734
4735}
4736
4738{
4739 if ((this->getModel()).isModelLinearized()) {
4741 } else {
4742 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHssRatio());
4743 }
4744}
4745
4746mueeHvvssPol::mueeHvvssPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4747: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4748{
4749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4750 throw std::runtime_error("mueeHvvssPol called with a class whose parent is not NPbase");
4751
4752}
4753
4755{
4756 if ((this->getModel()).isModelLinearized()) {
4758 } else {
4760 }
4761}
4762
4763
4764mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4765: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4766{
4767 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4768 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4769
4770}
4771
4773{
4774 if ((this->getModel()).isModelLinearized()) {
4776 } else {
4777 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4778 }
4779}
4780
4781mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4782: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4783{
4784 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4785 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4786
4787}
4788
4790{
4791 if ((this->getModel()).isModelLinearized()) {
4793 } else {
4795 }
4796}
4797
4798mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4799: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4800{
4801 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4802 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4803
4804}
4805
4807{
4808 if ((this->getModel()).isModelLinearized()) {
4810 } else {
4811 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4812 }
4813}
4814
4815mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4816: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4817{
4818 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4819 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4820
4821}
4822
4824{
4825 if ((this->getModel()).isModelLinearized()) {
4827 } else {
4829 }
4830}
4831
4832mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4833: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4834{
4835 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4836 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4837
4838}
4839
4841{
4842 if ((this->getModel()).isModelLinearized()) {
4844 } else {
4846 }
4847}
4848
4849mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4850: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4851{
4852 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4853 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4854
4855}
4856
4858{
4859 if ((this->getModel()).isModelLinearized()) {
4861 } else {
4863 }
4864}
4865
4866mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4867: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4868{
4869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4870 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4871
4872}
4873
4875{
4876 if ((this->getModel()).isModelLinearized()) {
4878 } else {
4879 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4880 }
4881}
4882
4883mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4884: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4885{
4886 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4887 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4888
4889}
4890
4892{
4893 if ((this->getModel()).isModelLinearized()) {
4895 } else {
4897 }
4898}
4899
4900mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4901: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4902{
4903 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4904 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4905
4906}
4907
4909{
4910 if ((this->getModel()).isModelLinearized()) {
4912 } else {
4913 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4914 }
4915}
4916
4917mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4918: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4919{
4920 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4921 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4922
4923}
4924
4926{
4927 if ((this->getModel()).isModelLinearized()) {
4929 } else {
4931 }
4932}
4933
4934mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4935: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4936{
4937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4938 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4939
4940}
4941
4943{
4944 if ((this->getModel()).isModelLinearized()) {
4946 } else {
4948 }
4949}
4950
4951mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4952: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4953{
4954 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4955 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4956
4957}
4958
4960{
4961 if ((this->getModel()).isModelLinearized()) {
4963 } else {
4965 }
4966}
4967
4968mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4969: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4970{
4971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4972 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4973
4974}
4975
4977{
4978 if ((this->getModel()).isModelLinearized()) {
4980 } else {
4982 }
4983}
4984
4985mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4986: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4987{
4988 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4989 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4990
4991}
4992
4994{
4995 if ((this->getModel()).isModelLinearized()) {
4997 } else {
4999 }
5000}
5001
5002mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5004{
5005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5006 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
5007}
5008
5010{
5011 if ((this->getModel()).isModelLinearized()) {
5013 } else {
5014 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5015 }
5016}
5017
5018mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
5019: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
5020{
5021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5022 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
5023}
5024
5026{
5027 if ((this->getModel()).isModelLinearized()) {
5029 } else {
5031 }
5032}
5033
5034mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
5035: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5036{
5037 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5038 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
5039}
5040
5042{
5043 if ((this->getModel()).isModelLinearized()) {
5045 } else {
5046 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
5047 }
5048}
5049
5050mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
5051: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
5052{
5053 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5054 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
5055}
5056
5058{
5059 if ((this->getModel()).isModelLinearized()) {
5061 } else {
5063 }
5064}
5065
5066
5067// Production signal strengths at mu+ mu- colliders
5068// ------------------------------------------------
5069
5070mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
5071: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5072{
5073 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5074 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
5075}
5076
5078{
5079 return myNPbase->mummZH(sqrt_s);
5080}
5081
5082
5083mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
5084: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5085{
5086 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5087 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
5088}
5089
5091{
5092 return myNPbase->mummHvv(sqrt_s);
5093}
5094
5095
5096mummHmm::mummHmm(const StandardModel& SM_i, const double sqrt_s_i)
5097: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5098{
5099 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5100 throw std::runtime_error("mummHmm called with a class whose parent is not NPbase");
5101}
5102
5104{
5105 return myNPbase->mummHmm(sqrt_s);
5106}
5107
5108
5109mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
5110: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5111{
5112 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5113 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
5114}
5115
5117{
5118 return myNPbase->mummttH(sqrt_s);
5119}
5120
5121
5122// Full signal strengths at mu+ mu- colliders
5123// -------------------------------------------
5124
5125
5126mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
5127: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5128{
5129 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5130 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
5131}
5132
5134{
5135 if ((this->getModel()).isModelLinearized()) {
5136 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5137 } else {
5138 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
5139 }
5140}
5141
5142mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
5143: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5144{
5145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5146 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5147}
5148
5150{
5151 if ((this->getModel()).isModelLinearized()) {
5152 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5153 } else {
5154 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
5155 }
5156}
5157
5158mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
5159: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5160{
5161 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5162 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
5163}
5164
5166{
5167 if ((this->getModel()).isModelLinearized()) {
5168 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5169 } else {
5170 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
5171 }
5172}
5173
5174mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
5175: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5176{
5177 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5178 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
5179}
5180
5182{
5183 if ((this->getModel()).isModelLinearized()) {
5184 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5185 } else {
5186 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
5187 }
5188}
5189
5190mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5191: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5192{
5193 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5194 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
5195}
5196
5198{
5199 if ((this->getModel()).isModelLinearized()) {
5200 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5201 } else {
5203 }
5204}
5205
5206mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5207: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5208{
5209 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5210 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
5211}
5212
5214{
5215 if ((this->getModel()).isModelLinearized()) {
5216 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5217 } else {
5218 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
5219 }
5220}
5221
5222mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5223: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5224{
5225 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5226 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5227}
5228
5230{
5231 if ((this->getModel()).isModelLinearized()) {
5232 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5233 } else {
5234 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5235 }
5236}
5237
5238mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5239: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5240{
5241 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5242 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5243}
5244
5246{
5247 if ((this->getModel()).isModelLinearized()) {
5248 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5249 } else {
5250 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5251 }
5252}
5253
5254mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5255: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5256{
5257 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5258 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5259}
5260
5262{
5263 if ((this->getModel()).isModelLinearized()) {
5264 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5265 } else {
5266 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5267 }
5268}
5269
5270
5271
5272mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5273: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5274{
5275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5276 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5277}
5278
5280{
5281 if ((this->getModel()).isModelLinearized()) {
5282 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5283 } else {
5284 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5285 }
5286}
5287
5288mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5289: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5290{
5291 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5292 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5293}
5294
5296{
5297 if ((this->getModel()).isModelLinearized()) {
5298 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5299 } else {
5300 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5301 }
5302}
5303
5304mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5305: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5306{
5307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5308 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5309}
5310
5312{
5313 if ((this->getModel()).isModelLinearized()) {
5314 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5315 } else {
5316 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5317 }
5318}
5319
5320mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5321: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5322{
5323 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5324 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5325}
5326
5328{
5329 if ((this->getModel()).isModelLinearized()) {
5330 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5331 } else {
5332 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5333 }
5334}
5335
5336mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5337: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5338{
5339 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5340 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5341}
5342
5344{
5345 if ((this->getModel()).isModelLinearized()) {
5346 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5347 } else {
5349 }
5350}
5351
5352mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5353: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5354{
5355 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5356 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5357}
5358
5360{
5361 if ((this->getModel()).isModelLinearized()) {
5362 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5363 } else {
5364 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5365 }
5366}
5367
5368mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5369: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5370{
5371 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5372 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5373}
5374
5376{
5377 if ((this->getModel()).isModelLinearized()) {
5378 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5379 } else {
5380 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5381 }
5382}
5383
5384mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5385: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5386{
5387 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5388 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5389}
5390
5392{
5393 if ((this->getModel()).isModelLinearized()) {
5394 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5395 } else {
5396 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5397 }
5398}
5399
5400mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5401: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5402{
5403 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5404 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5405}
5406
5408{
5409 if ((this->getModel()).isModelLinearized()) {
5410 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5411 } else {
5412 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5413 }
5414}
5415
5416
5417
5418mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5419: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5420{
5421 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5422 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5423}
5424
5426{
5427 if ((this->getModel()).isModelLinearized()) {
5428 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5429 } else {
5430 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5431 }
5432}
5433
5434mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5435: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5436{
5437 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5438 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5439}
5440
5442{
5443 if ((this->getModel()).isModelLinearized()) {
5444 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5445 } else {
5446 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5447 }
5448}
5449
5450mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5451: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5452{
5453 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5454 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5455}
5456
5458{
5459 if ((this->getModel()).isModelLinearized()) {
5460 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5461 } else {
5462 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5463 }
5464}
5465
5466mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5467: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5468{
5469 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5470 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5471}
5472
5474{
5475 if ((this->getModel()).isModelLinearized()) {
5476 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5477 } else {
5478 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5479 }
5480}
5481
5482mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5483: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5484{
5485 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5486 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5487}
5488
5490{
5491 if ((this->getModel()).isModelLinearized()) {
5492 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5493 } else {
5495 }
5496}
5497
5498mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5499: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5500{
5501 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5502 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5503}
5504
5506{
5507 if ((this->getModel()).isModelLinearized()) {
5508 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5509 } else {
5510 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5511 }
5512}
5513
5514mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5515: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5516{
5517 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5518 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5519}
5520
5522{
5523 if ((this->getModel()).isModelLinearized()) {
5524 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5525 } else {
5526 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5527 }
5528}
5529
5530mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5531: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5532{
5533 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5534 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5535}
5536
5538{
5539 if ((this->getModel()).isModelLinearized()) {
5540 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5541 } else {
5543 }
5544}
5545
5546mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5547: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5548{
5549 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5550 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5551}
5552
5554{
5555 if ((this->getModel()).isModelLinearized()) {
5556 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5557 } else {
5559 }
5560}
5561
5562
5563
5564mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5565: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5566{
5567 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5568 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5569}
5570
5572{
5573 if ((this->getModel()).isModelLinearized()) {
5574 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5575 } else {
5576 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5577 }
5578}
5579
5580mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5581: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5582{
5583 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5584 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5585}
5586
5588{
5589 if ((this->getModel()).isModelLinearized()) {
5590 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5591 } else {
5592 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5593 }
5594}
5595
5596mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5597: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5598{
5599 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5600 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5601}
5602
5604{
5605 if ((this->getModel()).isModelLinearized()) {
5606 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5607 } else {
5608 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5609 }
5610}
5611
5612mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5613: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5614{
5615 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5616 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5617}
5618
5620{
5621 if ((this->getModel()).isModelLinearized()) {
5622 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5623 } else {
5624 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5625 }
5626}
5627
5628mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5629: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5630{
5631 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5632 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5633}
5634
5636{
5637 if ((this->getModel()).isModelLinearized()) {
5638 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5639 } else {
5641 }
5642}
5643
5644mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5645: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5646{
5647 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5648 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5649}
5650
5652{
5653 if ((this->getModel()).isModelLinearized()) {
5654 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5655 } else {
5656 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5657 }
5658}
5659
5660mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5661: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5662{
5663 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5664 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5665}
5666
5668{
5669 if ((this->getModel()).isModelLinearized()) {
5670 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5671 } else {
5672 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5673 }
5674}
5675
5676mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5677: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5678{
5679 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5680 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5681}
5682
5684{
5685 if ((this->getModel()).isModelLinearized()) {
5686 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5687 } else {
5689 }
5690}
5691
5692mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5694{
5695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5696 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5697}
5698
5700{
5701 if ((this->getModel()).isModelLinearized()) {
5702 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5703 } else {
5705 }
5706}
5707
5708
5709mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5710: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5711{
5712 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5713 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5714}
5715
5717{
5718 if ((this->getModel()).isModelLinearized()) {
5719 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5720 } else {
5721 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5722 }
5723}
5724
5725mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5726: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5727{
5728 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5729 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5730}
5731
5733{
5734 if ((this->getModel()).isModelLinearized()) {
5735 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5736 } else {
5737 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5738 }
5739}
5740
5741mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5742: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5743{
5744 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5745 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5746}
5747
5749{
5750 if ((this->getModel()).isModelLinearized()) {
5751 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5752 } else {
5753 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5754 }
5755}
5756
5757mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5758: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5759{
5760 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5761 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5762}
5763
5765{
5766 if ((this->getModel()).isModelLinearized()) {
5767 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5768 } else {
5769 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5770 }
5771}
5772
5773mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5774: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5775{
5776 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5777 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5778}
5779
5781{
5782 if ((this->getModel()).isModelLinearized()) {
5783 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5784 } else {
5786 }
5787}
5788
5789mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5790: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5791{
5792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5793 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5794}
5795
5797{
5798 if ((this->getModel()).isModelLinearized()) {
5799 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5800 } else {
5801 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5802 }
5803}
5804
5805mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5806: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5807{
5808 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5809 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5810}
5811
5813{
5814 if ((this->getModel()).isModelLinearized()) {
5815 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5816 } else {
5817 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5818 }
5819}
5820
5821mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5822: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5823{
5824 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5825 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5826}
5827
5829{
5830 if ((this->getModel()).isModelLinearized()) {
5831 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5832 } else {
5834 }
5835}
5836
5837mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5838: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5839{
5840 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5841 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5842}
5843
5845{
5846 if ((this->getModel()).isModelLinearized()) {
5847 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5848 } else {
5850 }
5851}
5852
5853
5854// The same in the narrow width approximation
5855
5856mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5857: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5858{
5859 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5860 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5861}
5862
5864{
5865 if ((this->getModel()).isModelLinearized()) {
5866 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5867 } else {
5868 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5869 }
5870}
5871
5872mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5873: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5874{
5875 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5876 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5877}
5878
5880{
5881 if ((this->getModel()).isModelLinearized()) {
5882 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5883 } else {
5884 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5885 }
5886}
5887
5888mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5889: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5890{
5891 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5892 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5893}
5894
5896{
5897 if ((this->getModel()).isModelLinearized()) {
5898 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5899 } else {
5900 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5901 }
5902}
5903
5904mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5905: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5906{
5907 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5908 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5909}
5910
5912{
5913 if ((this->getModel()).isModelLinearized()) {
5914 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5915 } else {
5916 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5917 }
5918}
5919
5920mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5921: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5922{
5923 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5924 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5925}
5926
5928{
5929 if ((this->getModel()).isModelLinearized()) {
5930 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5931 } else {
5933 }
5934}
5935
5936mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5937: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5938{
5939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5940 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5941}
5942
5944{
5945 if ((this->getModel()).isModelLinearized()) {
5946 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5947 } else {
5948 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5949 }
5950}
5951
5952mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5953: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5954{
5955 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5956 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5957}
5958
5960{
5961 if ((this->getModel()).isModelLinearized()) {
5962 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5963 } else {
5965 }
5966}
5967
5968mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5969: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5970{
5971 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5972 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5973}
5974
5976{
5977 if ((this->getModel()).isModelLinearized()) {
5978 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5979 } else {
5981 }
5982}
5983
5984mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5986{
5987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5988 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5989}
5990
5992{
5993 if ((this->getModel()).isModelLinearized()) {
5994 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5995 } else {
5997 }
5998}
5999
6000// Full signal strengths at ep colliders
6001// -------------------------------------
6002
6003muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
6004: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6005{
6006 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6007 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
6008
6009}
6010
6012{
6013 if ((this->getModel()).isModelLinearized()) {
6014 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6015 } else {
6016 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
6017 }
6018}
6019
6020muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
6021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6022{
6023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6024 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
6025
6026}
6027
6029{
6030 if ((this->getModel()).isModelLinearized()) {
6031 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
6032 } else {
6033 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
6034 }
6035}
6036
6037muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
6038: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6039{
6040 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6041 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
6042
6043}
6044
6046{
6047 if ((this->getModel()).isModelLinearized()) {
6048 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
6049 } else {
6050 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
6051 }
6052}
6053
6054muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6055: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6056{
6057 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6058 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
6059
6060}
6061
6063{
6064 if ((this->getModel()).isModelLinearized()) {
6065 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6066 } else {
6068 }
6069}
6070
6071muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6072: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6073{
6074 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6075 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
6076
6077}
6078
6080{
6081 if ((this->getModel()).isModelLinearized()) {
6082 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6083 } else {
6084 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
6085 }
6086}
6087
6088muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6089: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6090{
6091 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6092 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
6093
6094}
6095
6097{
6098 if ((this->getModel()).isModelLinearized()) {
6099 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6100 } else {
6102 }
6103}
6104
6105muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6106: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6107{
6108 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6109 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
6110
6111}
6112
6114{
6115 if ((this->getModel()).isModelLinearized()) {
6116 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6117 } else {
6119 }
6120}
6121
6122muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
6123: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6124{
6125 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6126 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
6127
6128}
6129
6131{
6132 if ((this->getModel()).isModelLinearized()) {
6133 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6134 } else {
6135 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
6136 }
6137}
6138
6139muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
6140: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6141{
6142 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6143 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
6144
6145}
6146
6148{
6149 if ((this->getModel()).isModelLinearized()) {
6150 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
6151 } else {
6152 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
6153 }
6154}
6155
6156muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
6157: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6158{
6159 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6160 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
6161
6162}
6163
6165{
6166 if ((this->getModel()).isModelLinearized()) {
6167 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
6168 } else {
6169 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
6170 }
6171}
6172
6173muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
6174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6175{
6176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6177 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
6178
6179}
6180
6182{
6183 if ((this->getModel()).isModelLinearized()) {
6184 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
6185 } else {
6187 }
6188}
6189
6190muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
6191: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6192{
6193 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6194 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
6195
6196}
6197
6199{
6200 if ((this->getModel()).isModelLinearized()) {
6201 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6202 } else {
6203 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
6204 }
6205}
6206
6207muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
6208: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6209{
6210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6211 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
6212
6213}
6214
6216{
6217 if ((this->getModel()).isModelLinearized()) {
6218 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
6219 } else {
6221 }
6222}
6223
6224muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6225: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6226{
6227 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6228 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6229
6230}
6231
6233{
6234 if ((this->getModel()).isModelLinearized()) {
6235 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6236 } else {
6238 }
6239}
6240
6241
6242// -----------------------------------------------------------------------------
6243// STXS bins
6244// -----------------------------------------------------------------------------
6245
6246// -----------------------------------------------------------------------------
6247// Stage 0
6248// -----------------------------------------------------------------------------
6249
6250STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6251: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6252{
6253 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6254 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6255
6256}
6257
6259{
6260 return myNPbase->STXS0_qqH(sqrt_s);
6261}
6262
6263
6264// -----------------------------------------------------------------------------
6265// Stage 1
6266// -----------------------------------------------------------------------------
6267
6269: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6270{
6271 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6272 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6273
6274}
6275
6277{
6278 if ((this->getModel()).isModelLinearized()) {
6279 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6280 } else {
6282 }
6283}
6284
6285
6287: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6288{
6289 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6290 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6291
6292}
6293
6295{
6296 if ((this->getModel()).isModelLinearized()) {
6297 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6298 } else {
6300 }
6301}
6302
6303
6304STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6305: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6306{
6307 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6308 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6309
6310}
6311
6313{
6314 if ((this->getModel()).isModelLinearized()) {
6315 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6316 } else {
6318 }
6319}
6320
6322: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6323{
6324 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6325 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6326
6327}
6328
6330{
6331 if ((this->getModel()).isModelLinearized()) {
6332 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6333 } else {
6335 }
6336}
6337
6339: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6340{
6341 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6342 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6343
6344}
6345
6347{
6348 if ((this->getModel()).isModelLinearized()) {
6349 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6350 } else {
6352 }
6353}
6354
6356: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6357{
6358 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6359 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6360
6361}
6362
6364{
6365 if ((this->getModel()).isModelLinearized()) {
6366 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6367 } else {
6369 }
6370}
6371
6373: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6374{
6375 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6376 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6377
6378}
6379
6381{
6382 if ((this->getModel()).isModelLinearized()) {
6383 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6384 } else {
6386 }
6387}
6388
6390: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6391{
6392 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6393 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6394
6395}
6396
6398{
6399 if ((this->getModel()).isModelLinearized()) {
6400 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6401 } else {
6403 }
6404}
6405
6406
6408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6409{
6410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6411 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6412
6413}
6414
6416{
6417 if ((this->getModel()).isModelLinearized()) {
6418 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6419 } else {
6421 }
6422}
6423
6424
6426: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6427{
6428 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6429 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6430
6431}
6432
6434{
6435 if ((this->getModel()).isModelLinearized()) {
6436 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6437 } else {
6439 }
6440}
6441
6442
6444: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6445{
6446 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6447 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6448
6449}
6450
6452{
6453 if ((this->getModel()).isModelLinearized()) {
6454 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6455 } else {
6457 }
6458}
6459
6460
6462: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6463{
6464 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6465 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6466
6467}
6468
6470{
6471 if ((this->getModel()).isModelLinearized()) {
6472 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6473 } else {
6475 }
6476}
6477
6478
6480: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6481{
6482 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6483 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6484
6485}
6486
6488{
6489 if ((this->getModel()).isModelLinearized()) {
6490 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6491 } else {
6493 }
6494}
6495
6496
6498: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6499{
6500 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6501 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6502
6503}
6504
6506{
6507 if ((this->getModel()).isModelLinearized()) {
6508 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6509 } else {
6511 }
6512}
6513
6514
6515
6517: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6518{
6519 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6520 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6521
6522}
6523
6525{
6526 if ((this->getModel()).isModelLinearized()) {
6527 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6528 } else {
6530 }
6531}
6532
6533
6534
6536: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6537{
6538 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6539 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6540
6541}
6542
6544{
6545 if ((this->getModel()).isModelLinearized()) {
6546 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6547 } else {
6549 }
6550}
6551
6552
6553
6555: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6556{
6557 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6558 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6559
6560}
6561
6563{
6564 if ((this->getModel()).isModelLinearized()) {
6565 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6566 } else {
6568 }
6569}
6570
6571
6572STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6573: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6574{
6575 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6576 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6577
6578}
6579
6581{
6582 if ((this->getModel()).isModelLinearized()) {
6583 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6584 } else {
6586 }
6587}
6588
6589
6591: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6592{
6593 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6594 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6595
6596}
6597
6599{
6600 if ((this->getModel()).isModelLinearized()) {
6601 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6602 } else {
6604 }
6605}
6606
6608: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6609{
6610 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6611 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6612
6613}
6614
6616{
6617 if ((this->getModel()).isModelLinearized()) {
6618 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6619 } else {
6621 }
6622}
6623
6624
6626: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6627{
6628 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6629 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6630
6631}
6632
6634{
6635 if ((this->getModel()).isModelLinearized()) {
6636 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6637 } else {
6639 }
6640}
6641
6642
6643
6645: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6646{
6647 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6648 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6649
6650}
6651
6653{
6654 if ((this->getModel()).isModelLinearized()) {
6656 } else {
6658 }
6659}
6660
6661
6662
6664: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6665{
6666 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6667 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6668
6669}
6670
6672{
6673 if ((this->getModel()).isModelLinearized()) {
6675 } else {
6677 }
6678}
6679
6680
6682: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6683{
6684 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6685 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6686
6687}
6688
6690{
6691 if ((this->getModel()).isModelLinearized()) {
6692 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6693 } else {
6695 }
6696}
6697
6699: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6700{
6701 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6702 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6703
6704}
6705
6707{
6708 if ((this->getModel()).isModelLinearized()) {
6709 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6710 } else {
6712 }
6713}
6714
6716: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6717{
6718 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6719 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6720
6721}
6722
6724{
6725 if ((this->getModel()).isModelLinearized()) {
6726 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6727 } else {
6729 }
6730}
6731
6732
6734: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6735{
6736 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6737 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6738
6739}
6740
6742{
6743 if ((this->getModel()).isModelLinearized()) {
6745 } else {
6747 }
6748}
6749
6750
6752: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6753{
6754 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6755 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6756
6757}
6758
6760{
6761 if ((this->getModel()).isModelLinearized()) {
6763 } else {
6765 }
6766}
6767
6768
6770: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6771{
6772 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6773 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6774
6775}
6776
6778{
6779 if ((this->getModel()).isModelLinearized()) {
6780 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6781 } else {
6783 }
6784}
6785
6786STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6787: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6788{
6789 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6790 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6791
6792}
6793
6795{
6796 if ((this->getModel()).isModelLinearized()) {
6797 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6798 } else {
6800 }
6801}
6802
6803
6805: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6806{
6807 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6808 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6809
6810}
6811
6813{
6814 if ((this->getModel()).isModelLinearized()) {
6815 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6816 } else {
6818 }
6819}
6820
6821
6823: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6824{
6825 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6826 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6827
6828}
6829
6831{
6832 if ((this->getModel()).isModelLinearized()) {
6833 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6834 } else {
6836 }
6837}
6838
6839
6840
6842: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6843{
6844 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6845 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6846
6847}
6848
6850{
6851 if ((this->getModel()).isModelLinearized()) {
6853 } else {
6855 }
6856}
6857
6858
6859
6861: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6862{
6863 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6864 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6865
6866}
6867
6869{
6870 if ((this->getModel()).isModelLinearized()) {
6872 } else {
6874 }
6875}
6876
6877
6879: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6880{
6881 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6882 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6883
6884}
6885
6887{
6888 if ((this->getModel()).isModelLinearized()) {
6889 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6890 } else {
6892 }
6893}
6894
6896: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6897{
6898 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6899 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6900
6901}
6902
6904{
6905 if ((this->getModel()).isModelLinearized()) {
6906 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6907 } else {
6909 }
6910}
6911
6913: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6914{
6915 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6916 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6917
6918}
6919
6921{
6922 if ((this->getModel()).isModelLinearized()) {
6923 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6924 } else {
6926 }
6927}
6928
6929
6931: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6932{
6933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6934 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6935
6936}
6937
6939{
6940 if ((this->getModel()).isModelLinearized()) {
6942 } else {
6944 }
6945}
6946
6947
6949: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6950{
6951 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6952 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6953
6954}
6955
6957{
6958 if ((this->getModel()).isModelLinearized()) {
6960 } else {
6962 }
6963}
6964
6965
6967: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6968{
6969 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6970 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6971
6972}
6973
6975{
6976 if ((this->getModel()).isModelLinearized()) {
6977 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6978 } else {
6980 }
6981}
6982
6983
6985: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6986{
6987 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6988 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6989
6990}
6991
6993{
6994 if ((this->getModel()).isModelLinearized()) {
6996 } else {
6998 }
6999}
7000
7001
7003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7004{
7005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7006 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
7007
7008}
7009
7011{
7012 if ((this->getModel()).isModelLinearized()) {
7013 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7014 } else {
7016 }
7017}
7018
7019
7021: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7022{
7023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7024 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
7025
7026}
7027
7029{
7030 if ((this->getModel()).isModelLinearized()) {
7031 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7032 } else {
7034 }
7035}
7036
7037
7039: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7040{
7041 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7042 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7043
7044}
7045
7047{
7048 if ((this->getModel()).isModelLinearized()) {
7049 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7050 } else {
7052 }
7053}
7054
7055
7057: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7058{
7059 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7060 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7061
7062}
7063
7065{
7066 if ((this->getModel()).isModelLinearized()) {
7067 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7068 } else {
7070 }
7071}
7072
7073
7075: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7076{
7077 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7078 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
7079
7080}
7081
7083{
7084 if ((this->getModel()).isModelLinearized()) {
7086 } else {
7088 }
7089}
7090
7091
7093: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7094{
7095 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7096 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
7097
7098}
7099
7101{
7102 if ((this->getModel()).isModelLinearized()) {
7103 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7104 } else {
7106 }
7107}
7108
7109
7111: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7112{
7113 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7114 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
7115
7116}
7117
7119{
7120 if ((this->getModel()).isModelLinearized()) {
7121 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7122 } else {
7124 }
7125}
7126
7127
7129: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7130{
7131 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7132 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7133
7134}
7135
7137{
7138 if ((this->getModel()).isModelLinearized()) {
7139 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7140 } else {
7142 }
7143}
7144
7145
7147: ThObservable(SM_i), sqrt_s(sqrt_s_i)
7148{
7149 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7150 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7151
7152}
7153
7155{
7156 if ((this->getModel()).isModelLinearized()) {
7157 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
7158 } else {
7160 }
7161}
7162
7163
7164
7165// -----------------------------------------------------------------------------
7166// Stage 1.2
7167// -----------------------------------------------------------------------------
7168
7169STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7170: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7171{
7172 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7173 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7174
7175}
7176
7178{
7179 double BrHXXRatio = 1.0;
7180 if (fstate == 1){
7181 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7182 } else if (fstate == 2){
7183 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7184 } else if (fstate == 3){
7185 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7186 } else if (fstate == 4){
7187 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7188 } else {
7189 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7190 }
7191
7192 if ((this->getModel()).isModelLinearized()) {
7193 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7194 } else {
7195 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
7196 }
7197}
7198
7199// -----------------------------------------------------------------------------
7200
7201STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7202: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7203{
7204 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7205 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7206
7207}
7208
7210{
7211 double BrHXXRatio = 1.0;
7212 if (fstate == 1){
7213 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7214 } else if (fstate == 2){
7215 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7216 } else if (fstate == 3){
7217 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7218 } else if (fstate == 4){
7219 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7220 } else {
7221 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7222 }
7223
7224 if ((this->getModel()).isModelLinearized()) {
7225 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7226 } else {
7227 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7228 }
7229}
7230
7231// -----------------------------------------------------------------------------
7232
7233STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7234: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7235{
7236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7237 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7238
7239}
7240
7242{
7243 double BrHXXRatio = 1.0;
7244 if (fstate == 1){
7245 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7246 } else if (fstate == 2){
7247 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7248 } else if (fstate == 3){
7249 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7250 } else if (fstate == 4){
7251 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7252 } else {
7253 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7254 }
7255
7256 if ((this->getModel()).isModelLinearized()) {
7257 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7258 } else {
7259 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7260 }
7261}
7262
7263// -----------------------------------------------------------------------------
7264
7265STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7266: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7267{
7268 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7269 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7270
7271}
7272
7274{
7275 double BrHXXRatio = 1.0;
7276 if (fstate == 1){
7277 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7278 } else if (fstate == 2){
7279 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7280 } else if (fstate == 3){
7281 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7282 } else if (fstate == 4){
7283 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7284 } else {
7285 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7286 }
7287
7288 if ((this->getModel()).isModelLinearized()) {
7289 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7290 } else {
7291 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7292 }
7293}
7294
7295
7296// -----------------------------------------------------------------------------
7297
7298STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7299: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7300{
7301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7302 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7303
7304}
7305
7307{
7308 //-- Production:
7309 double weight = 1.0; //If normalized to the SM
7310
7311 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7312 double muProd1 = muProd -1.0;
7313 double muProd2 = 0.0;
7314 //-- Decay:
7315 double BrHXXRatio = 1.0;
7316 double dBrHXXRatio1 = 0.0;
7317 double dBrHXXRatio2 = 0.0;
7318
7319 if (fstate == 1){
7320 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7321 dBrHXXRatio1 = BrHXXRatio - 1.0;
7322 dBrHXXRatio2 = 0.0;
7323 } else if (fstate == 2){
7324 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7325 dBrHXXRatio1 = BrHXXRatio - 1.0;
7326 dBrHXXRatio2 = 0.0;
7327 } else if (fstate == 3){
7328 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7329 dBrHXXRatio1 = BrHXXRatio - 1.0;
7330 dBrHXXRatio2 = 0.0;
7331 } else if (fstate == 4){
7332 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7333 dBrHXXRatio1 = BrHXXRatio - 1.0;
7334 dBrHXXRatio2 = 0.0;
7335 } else {
7336 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7337 }
7338
7339 //-- Production x Decay:
7340 if ((this->getModel()).isModelLinearized()){
7341 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7342 } else if((this->getModel()).isModelNPquadratic()){
7343 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7344 } else {
7345 return weight*(muProd)*(BrHXXRatio);
7346 }
7347}
7348
7349
7350
7351
7352
7353// -----------------------------------------------------------------------------
7354
7355//VM:STXS2024;
7356STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7357: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7358{
7359 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7360 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7361
7362}
7363
7365{
7366 //-- Production:
7367 double weight = 1.0; //If normalized to the SM
7368 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7369 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7370 double muProd1 = muProd -1.0;
7371 double muProd2 = 0.0;
7372
7373 //-- Decay:
7374 double BrHXXRatio = 1.0;
7375 double dBrHXXRatio1 = 0.0;
7376 double dBrHXXRatio2 = 0.0;
7377 if (fstate==0){
7378 // Use for Cross-section [pb] with no Higgs-boson decay
7379 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7380 } else if (fstate == 1){
7381 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7382 dBrHXXRatio1 = BrHXXRatio - 1.0;
7383 dBrHXXRatio2 = 0.0;
7384 } else if (fstate == 2){
7385 BrHXXRatio = (myNPbase->BrHgagaRatio());
7386 dBrHXXRatio1 = BrHXXRatio - 1.0;
7387 dBrHXXRatio2 = 0.0;
7388 } else if (fstate == 3){
7389 BrHXXRatio = (myNPbase->BrHbbRatio());
7390 dBrHXXRatio1 = BrHXXRatio - 1.0;
7391 dBrHXXRatio2 = 0.0;
7392 } else if (fstate == 4){
7393 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7394 dBrHXXRatio1 = BrHXXRatio - 1.0;
7395 dBrHXXRatio2 = 0.0;
7396 } else if (fstate == 5){
7397 BrHXXRatio = (myNPbase->BrHtautauRatio());
7398 dBrHXXRatio1 = BrHXXRatio - 1.0;
7399 dBrHXXRatio2 = 0.0;
7400 } else if (fstate == 6){
7401 BrHXXRatio = (myNPbase->BrHWWRatio());
7402 dBrHXXRatio1 = BrHXXRatio - 1.0;
7403 dBrHXXRatio2 = 0.0;
7404 } else if (fstate == 7){
7405 BrHXXRatio = (myNPbase->BrHZZRatio());
7406 dBrHXXRatio1 = BrHXXRatio - 1.0;
7407 dBrHXXRatio2 = 0.0;
7408 } else {
7409 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7410 }
7411
7412 //-- Production x Decay:
7413 if ((this->getModel()).isModelLinearized()){
7414 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7415 } else if((this->getModel()).isModelNPquadratic()){
7416 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7417 } else {
7418 return weight*(muProd)*(BrHXXRatio);
7419 }
7420
7421}
7422
7423
7424
7425// -----------------------------------------------------------------------------
7426
7427//VM:STXS2024;
7428STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7429: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7430{
7431 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7432 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7433
7434}
7435
7437{
7438 //-- Production:
7439 double weight = 1.0; //If normalized to the SM
7440 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7441 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7442 double muProd1 = muProd -1.0;
7443 double muProd2 = 0.0;
7444
7445 //-- Decay:
7446 double BrHXXRatio = 1.0;
7447 double dBrHXXRatio1 = 0.0;
7448 double dBrHXXRatio2 = 0.0;
7449 if (fstate==0){
7450 // Use for Cross-section [pb] with no Higgs-boson decay
7451 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7452 } else if (fstate == 1){
7453 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7454 dBrHXXRatio1 = BrHXXRatio - 1.0;
7455 dBrHXXRatio2 = 0.0;
7456 } else if (fstate == 2){
7457 BrHXXRatio = (myNPbase->BrHgagaRatio());
7458 dBrHXXRatio1 = BrHXXRatio - 1.0;
7459 dBrHXXRatio2 = 0.0;
7460 } else if (fstate == 3){
7461 BrHXXRatio = (myNPbase->BrHbbRatio());
7462 dBrHXXRatio1 = BrHXXRatio - 1.0;
7463 dBrHXXRatio2 = 0.0;
7464 } else if (fstate == 4){
7465 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7466 dBrHXXRatio1 = BrHXXRatio - 1.0;
7467 dBrHXXRatio2 = 0.0;
7468 } else if (fstate == 5){
7469 BrHXXRatio = (myNPbase->BrHtautauRatio());
7470 dBrHXXRatio1 = BrHXXRatio - 1.0;
7471 dBrHXXRatio2 = 0.0;
7472 } else if (fstate == 6){
7473 BrHXXRatio = (myNPbase->BrHWWRatio());
7474 dBrHXXRatio1 = BrHXXRatio - 1.0;
7475 dBrHXXRatio2 = 0.0;
7476 } else if (fstate == 7){
7477 BrHXXRatio = (myNPbase->BrHZZRatio());
7478 dBrHXXRatio1 = BrHXXRatio - 1.0;
7479 dBrHXXRatio2 = 0.0;
7480 } else {
7481 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7482 }
7483
7484 //-- Production x Decay:
7485 if ((this->getModel()).isModelLinearized()){
7486 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7487 } else if((this->getModel()).isModelNPquadratic()){
7488 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7489 } else {
7490 return weight*(muProd)*(BrHXXRatio);
7491 }
7492
7493}
7494
7495
7496
7497
7498// -----------------------------------------------------------------------------
7499
7500//VM:STXS2024;
7501STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7502: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7503{
7504 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7505 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7506
7507}
7508
7510{
7511 //-- Production:
7512 double weight = 1.0; //If normalized to the SM
7513 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7514 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7516 /(6.6369 + 20.642);
7517 double muProd1 = muProd -1.0;
7518 double muProd2 = 0.0;
7519
7520 //-- Decay:
7521 double BrHXXRatio = 1.0;
7522 double dBrHXXRatio1 = 0.0;
7523 double dBrHXXRatio2 = 0.0;
7524 if (fstate==0){
7525 // Use for Cross-section [pb] with no Higgs-boson decay
7526 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7527 } else if (fstate == 1){
7528 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7529 dBrHXXRatio1 = BrHXXRatio - 1.0;
7530 dBrHXXRatio2 = 0.0;
7531 } else if (fstate == 2){
7532 BrHXXRatio = (myNPbase->BrHgagaRatio());
7533 dBrHXXRatio1 = BrHXXRatio - 1.0;
7534 dBrHXXRatio2 = 0.0;
7535 } else if (fstate == 3){
7536 BrHXXRatio = (myNPbase->BrHbbRatio());
7537 dBrHXXRatio1 = BrHXXRatio - 1.0;
7538 dBrHXXRatio2 = 0.0;
7539 } else if (fstate == 4){
7540 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7541 dBrHXXRatio1 = BrHXXRatio - 1.0;
7542 dBrHXXRatio2 = 0.0;
7543 } else if (fstate == 5){
7544 BrHXXRatio = (myNPbase->BrHtautauRatio());
7545 dBrHXXRatio1 = BrHXXRatio - 1.0;
7546 dBrHXXRatio2 = 0.0;
7547 } else if (fstate == 6){
7548 BrHXXRatio = (myNPbase->BrHWWRatio());
7549 dBrHXXRatio1 = BrHXXRatio - 1.0;
7550 dBrHXXRatio2 = 0.0;
7551 } else if (fstate == 7){
7552 BrHXXRatio = (myNPbase->BrHZZRatio());
7553 dBrHXXRatio1 = BrHXXRatio - 1.0;
7554 dBrHXXRatio2 = 0.0;
7555 } else {
7556 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7557 }
7558
7559 //-- Production x Decay:
7560 if ((this->getModel()).isModelLinearized()){
7561 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7562 } else if((this->getModel()).isModelNPquadratic()){
7563 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7564 } else {
7565 return weight*(muProd)*(BrHXXRatio);
7566 }
7567
7568}
7569
7570
7571
7572
7573// -----------------------------------------------------------------------------
7574
7575//VM:STXS2024;
7576STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7577: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7578{
7579 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7580 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7581
7582}
7583
7585{
7586 //-- Production:
7587 double weight = 1.0; //If normalized to the SM
7588 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7589
7590 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7591 double muProd1 = muProd -1.0;
7592 double muProd2 = 0.0;
7593
7594 //-- Decay:
7595 double BrHXXRatio = 1.0;
7596 double dBrHXXRatio1 = 0.0;
7597 double dBrHXXRatio2 = 0.0;
7598 if (fstate==0){
7599 // Use for Cross-section [pb] with no Higgs-boson decay
7600 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7601 } else if (fstate == 1){
7602 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7603 dBrHXXRatio1 = BrHXXRatio - 1.0;
7604 dBrHXXRatio2 = 0.0;
7605 } else if (fstate == 2){
7606 BrHXXRatio = (myNPbase->BrHgagaRatio());
7607 dBrHXXRatio1 = BrHXXRatio - 1.0;
7608 dBrHXXRatio2 = 0.0;
7609 } else if (fstate == 3){
7610 BrHXXRatio = (myNPbase->BrHbbRatio());
7611 dBrHXXRatio1 = BrHXXRatio - 1.0;
7612 dBrHXXRatio2 = 0.0;
7613 } else if (fstate == 4){
7614 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7615 dBrHXXRatio1 = BrHXXRatio - 1.0;
7616 dBrHXXRatio2 = 0.0;
7617 } else if (fstate == 5){
7618 BrHXXRatio = (myNPbase->BrHtautauRatio());
7619 dBrHXXRatio1 = BrHXXRatio - 1.0;
7620 dBrHXXRatio2 = 0.0;
7621 } else if (fstate == 6){
7622 BrHXXRatio = (myNPbase->BrHWWRatio());
7623 dBrHXXRatio1 = BrHXXRatio - 1.0;
7624 dBrHXXRatio2 = 0.0;
7625 } else if (fstate == 7){
7626 BrHXXRatio = (myNPbase->BrHZZRatio());
7627 dBrHXXRatio1 = BrHXXRatio - 1.0;
7628 dBrHXXRatio2 = 0.0;
7629 } else {
7630 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7631 }
7632
7633 //-- Production x Decay:
7634 if ((this->getModel()).isModelLinearized()){
7635 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7636 } else if((this->getModel()).isModelNPquadratic()){
7637 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7638 } else {
7639 return weight*(muProd)*(BrHXXRatio);
7640 }
7641
7642}
7643
7644
7645
7646
7647
7648
7649
7650// -----------------------------------------------------------------------------
7651
7652//AG:STXS2024
7653STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7654: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7655{
7656 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7657 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7658
7659}
7660
7662{
7663 //-- Production:
7664 double weight = 1.0; //If normalized to the SM
7665 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7666 double muProd1 = muProd -1.0;
7667 double muProd2 = 0.0;
7668
7669 //-- Decay:
7670 double BrHXXRatio = 1.0;
7671 double dBrHXXRatio1 = 0.0;
7672 double dBrHXXRatio2 = 0.0;
7673 if (fstate==0){
7674 // Use for Cross-section [pb] with no Higgs-boson decay
7675 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7676 } else if (fstate == 1){
7677 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7678 dBrHXXRatio1 = BrHXXRatio - 1.0;
7679 dBrHXXRatio2 = 0.0;
7680 } else if (fstate == 2){
7681 BrHXXRatio = (myNPbase->BrHgagaRatio());
7682 dBrHXXRatio1 = BrHXXRatio - 1.0;
7683 dBrHXXRatio2 = 0.0;
7684 } else if (fstate == 3){
7685 BrHXXRatio = (myNPbase->BrHbbRatio());
7686 dBrHXXRatio1 = BrHXXRatio - 1.0;
7687 dBrHXXRatio2 = 0.0;
7688 } else if (fstate == 4){
7689 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7690 dBrHXXRatio1 = BrHXXRatio - 1.0;
7691 dBrHXXRatio2 = 0.0;
7692 } else if (fstate == 5){
7693 BrHXXRatio = (myNPbase->BrHtautauRatio());
7694 dBrHXXRatio1 = BrHXXRatio - 1.0;
7695 dBrHXXRatio2 = 0.0;
7696 } else if (fstate == 6){
7697 BrHXXRatio = (myNPbase->BrHWWRatio());
7698 dBrHXXRatio1 = BrHXXRatio - 1.0;
7699 dBrHXXRatio2 = 0.0;
7700 } else if (fstate == 7){
7701 BrHXXRatio = (myNPbase->BrHZZRatio());
7702 dBrHXXRatio1 = BrHXXRatio - 1.0;
7703 dBrHXXRatio2 = 0.0;
7704 } else {
7705 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7706 }
7707
7708 //-- Production x Decay:
7709 if ((this->getModel()).isModelLinearized()){
7710 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7711 } else if((this->getModel()).isModelNPquadratic()){
7712 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7713 } else {
7714 return weight*(muProd)*(BrHXXRatio);
7715 }
7716
7717}
7718
7719// -----------------------------------------------------------------------------
7720
7721//AG:STXS2024
7722STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7723: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7724{
7725 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7726 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7727
7728}
7729
7731{
7732 //-- Production:
7733 double weight = 1.0; //If normalized to the SM
7734 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7735 double muProd1 = muProd -1.0;
7736 double muProd2 = 0.0;
7737
7738 //-- Decay:
7739 double BrHXXRatio = 1.0;
7740 double dBrHXXRatio1 = 0.0;
7741 double dBrHXXRatio2 = 0.0;
7742 if (fstate==0){
7743 // Use for Cross-section [pb] with no Higgs-boson decay
7744 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7745 } else if (fstate == 1){
7746 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7747 dBrHXXRatio1 = BrHXXRatio - 1.0;
7748 dBrHXXRatio2 = 0.0;
7749 } else if (fstate == 2){
7750 BrHXXRatio = (myNPbase->BrHgagaRatio());
7751 dBrHXXRatio1 = BrHXXRatio - 1.0;
7752 dBrHXXRatio2 = 0.0;
7753 } else if (fstate == 3){
7754 BrHXXRatio = (myNPbase->BrHbbRatio());
7755 dBrHXXRatio1 = BrHXXRatio - 1.0;
7756 dBrHXXRatio2 = 0.0;
7757 } else if (fstate == 4){
7758 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7759 dBrHXXRatio1 = BrHXXRatio - 1.0;
7760 dBrHXXRatio2 = 0.0;
7761 } else if (fstate == 5){
7762 BrHXXRatio = (myNPbase->BrHtautauRatio());
7763 dBrHXXRatio1 = BrHXXRatio - 1.0;
7764 dBrHXXRatio2 = 0.0;
7765 } else if (fstate == 6){
7766 BrHXXRatio = (myNPbase->BrHWWRatio());
7767 dBrHXXRatio1 = BrHXXRatio - 1.0;
7768 dBrHXXRatio2 = 0.0;
7769 } else if (fstate == 7){
7770 BrHXXRatio = (myNPbase->BrHZZRatio());
7771 dBrHXXRatio1 = BrHXXRatio - 1.0;
7772 dBrHXXRatio2 = 0.0;
7773 } else {
7774 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7775 }
7776
7777 //-- Production x Decay:
7778 if ((this->getModel()).isModelLinearized()){
7779 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7780 } else if((this->getModel()).isModelNPquadratic()){
7781 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7782 } else {
7783 return weight*(muProd)*(BrHXXRatio);
7784 }
7785
7786}
7787
7788// -----------------------------------------------------------------------------
7789
7790//AG:STXS2024
7791STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7792: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7793{
7794 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7795 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7796
7797}
7798
7800{
7801 //-- Production:
7802 double weight = 1.0; //If normalized to the SM
7803 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7804 double muProd1 = muProd -1.0;
7805 double muProd2 = 0.0;
7806
7807 //-- Decay:
7808 double BrHXXRatio = 1.0;
7809 double dBrHXXRatio1 = 0.0;
7810 double dBrHXXRatio2 = 0.0;
7811 if (fstate==0){
7812 // Use for Cross-section [pb] with no Higgs-boson decay
7813 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7814 } else if (fstate == 1){
7815 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7816 dBrHXXRatio1 = BrHXXRatio - 1.0;
7817 dBrHXXRatio2 = 0.0;
7818 } else if (fstate == 2){
7819 BrHXXRatio = (myNPbase->BrHgagaRatio());
7820 dBrHXXRatio1 = BrHXXRatio - 1.0;
7821 dBrHXXRatio2 = 0.0;
7822 } else if (fstate == 3){
7823 BrHXXRatio = (myNPbase->BrHbbRatio());
7824 dBrHXXRatio1 = BrHXXRatio - 1.0;
7825 dBrHXXRatio2 = 0.0;
7826 } else if (fstate == 4){
7827 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7828 dBrHXXRatio1 = BrHXXRatio - 1.0;
7829 dBrHXXRatio2 = 0.0;
7830 } else if (fstate == 5){
7831 BrHXXRatio = (myNPbase->BrHtautauRatio());
7832 dBrHXXRatio1 = BrHXXRatio - 1.0;
7833 dBrHXXRatio2 = 0.0;
7834 } else if (fstate == 6){
7835 BrHXXRatio = (myNPbase->BrHWWRatio());
7836 dBrHXXRatio1 = BrHXXRatio - 1.0;
7837 dBrHXXRatio2 = 0.0;
7838 } else if (fstate == 7){
7839 BrHXXRatio = (myNPbase->BrHZZRatio());
7840 dBrHXXRatio1 = BrHXXRatio - 1.0;
7841 dBrHXXRatio2 = 0.0;
7842 } else {
7843 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7844 }
7845
7846 //-- Production x Decay:
7847 if ((this->getModel()).isModelLinearized()){
7848 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7849 } else if((this->getModel()).isModelNPquadratic()){
7850 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7851 } else {
7852 return weight*(muProd)*(BrHXXRatio);
7853 }
7854
7855}
7856
7857
7858
7859// -----------------------------------------------------------------------------
7860
7861//VM:STXS2025
7862STXS12_ggH_pTH60_200_Nj1::STXS12_ggH_pTH60_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7863: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7864{
7865 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7866 throw std::runtime_error("STXS12_ggH_pTH60_200_Nj1 called with a class whose parent is not NPbase");
7867
7868}
7869
7871{
7872 //-- Production:
7873 double weight = 1.0; //If normalized to the SM
7874 double muProd = (4.50294*(myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s))+
7876 )/(4.50294+0.74712);
7877 double muProd1 = muProd -1.0;
7878 double muProd2 = 0.0;
7879
7880 //-- Decay:
7881 double BrHXXRatio = 1.0;
7882 double dBrHXXRatio1 = 0.0;
7883 double dBrHXXRatio2 = 0.0;
7884 if (fstate==0){
7885 // Use for Cross-section [pb] with no Higgs-boson decay
7886 weight = (4.50294+0.74712); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7887 } else if (fstate == 1){
7888 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7889 dBrHXXRatio1 = BrHXXRatio - 1.0;
7890 dBrHXXRatio2 = 0.0;
7891 } else if (fstate == 2){
7892 BrHXXRatio = (myNPbase->BrHgagaRatio());
7893 dBrHXXRatio1 = BrHXXRatio - 1.0;
7894 dBrHXXRatio2 = 0.0;
7895 } else if (fstate == 3){
7896 BrHXXRatio = (myNPbase->BrHbbRatio());
7897 dBrHXXRatio1 = BrHXXRatio - 1.0;
7898 dBrHXXRatio2 = 0.0;
7899 } else if (fstate == 4){
7900 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7901 dBrHXXRatio1 = BrHXXRatio - 1.0;
7902 dBrHXXRatio2 = 0.0;
7903 } else if (fstate == 5){
7904 BrHXXRatio = (myNPbase->BrHtautauRatio());
7905 dBrHXXRatio1 = BrHXXRatio - 1.0;
7906 dBrHXXRatio2 = 0.0;
7907 } else if (fstate == 6){
7908 BrHXXRatio = (myNPbase->BrHWWRatio());
7909 dBrHXXRatio1 = BrHXXRatio - 1.0;
7910 dBrHXXRatio2 = 0.0;
7911 } else if (fstate == 7){
7912 BrHXXRatio = (myNPbase->BrHZZRatio());
7913 dBrHXXRatio1 = BrHXXRatio - 1.0;
7914 dBrHXXRatio2 = 0.0;
7915 } else {
7916 throw std::runtime_error("STXS12_ggH_pTH60_200_Nj1 called with invalid argument for final state in fstate_i");
7917 }
7918
7919 //-- Production x Decay:
7920 if ((this->getModel()).isModelLinearized()){
7921 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7922 } else if((this->getModel()).isModelNPquadratic()){
7923 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7924 } else {
7925 return weight*(muProd)*(BrHXXRatio);
7926 }
7927
7928}
7929
7930
7931// -----------------------------------------------------------------------------
7932
7933STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7934: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7935{
7936 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7937 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7938
7939}
7940
7942{
7943
7944
7945 //-- Production:
7946 double weight = 1.0; //If normalized to the SM
7947
7948 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)));
7949 double muProd1 = muProd -1.0;
7950 double muProd2 = 0.0;
7951
7952 //-- Decay:
7953 double BrHXXRatio = 1.0;
7954 double dBrHXXRatio1 = 0.0;
7955 double dBrHXXRatio2 = 0.0;
7956
7957
7958
7959 if (fstate==0){
7960 // Use for Cross-section [pb] with no Higgs-boson decay
7961 weight = (1.24); //Ref: CMS note HIG-21-018-PAS-V3
7962 } else if (fstate == 1){
7963 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7964 dBrHXXRatio1 = BrHXXRatio - 1.0;
7965 dBrHXXRatio2 = 0.0;
7966 } else if (fstate == 2){
7967 BrHXXRatio = (myNPbase->BrHgagaRatio());
7968 dBrHXXRatio1 = BrHXXRatio - 1.0;
7969 dBrHXXRatio2 = 0.0;
7970 } else if (fstate == 3){
7971 BrHXXRatio = (myNPbase->BrHbbRatio());
7972 dBrHXXRatio1 = BrHXXRatio - 1.0;
7973 dBrHXXRatio2 = 0.0;
7974 } else if (fstate == 4){
7975 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7976 dBrHXXRatio1 = BrHXXRatio - 1.0;
7977 dBrHXXRatio2 = 0.0;
7978 } else if (fstate == 5){
7979 BrHXXRatio = (myNPbase->BrHtautauRatio());
7980 dBrHXXRatio1 = BrHXXRatio - 1.0;
7981 dBrHXXRatio2 = 0.0;
7982 } else if (fstate == 6){
7983 BrHXXRatio = (myNPbase->BrHWWRatio());
7984 dBrHXXRatio1 = BrHXXRatio - 1.0;
7985 dBrHXXRatio2 = 0.0;
7986 } else if (fstate == 7){
7987 BrHXXRatio = (myNPbase->BrHZZRatio());
7988 dBrHXXRatio1 = BrHXXRatio - 1.0;
7989 dBrHXXRatio2 = 0.0;
7990 } else {
7991 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7992 }
7993
7994
7995
7996 //-- Production x Decay:
7997 if ((this->getModel()).isModelLinearized()){
7998 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7999 } else if((this->getModel()).isModelNPquadratic()){
8000 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8001 } else {
8002 return weight*(muProd)*(BrHXXRatio);
8003 }
8004}
8005
8006// -----------------------------------------------------------------------------
8007
8008STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8009: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8010{
8011 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8012 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
8013
8014}
8015
8017{
8018
8019 //-- Production:
8020 double weight = 1.0; //If normalized to the SM
8021
8022
8024 double muProd1 = muProd -1.0;
8025 double muProd2 = 0.0;
8026
8027 //-- Decay:
8028 double BrHXXRatio = 1.0;
8029 double dBrHXXRatio1 = 0.0;
8030 double dBrHXXRatio2 = 0.0;
8031
8032
8033
8034 if (fstate==0){
8035 // Use for Cross-section [pb] with no Higgs-boson decay
8036 weight = (2.00); //Ref: CMS note HIG-21-018-PAS-V3
8037 } else if (fstate == 1){
8038 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8039 dBrHXXRatio1 = BrHXXRatio - 1.0;
8040 dBrHXXRatio2 = 0.0;
8041 } else if (fstate == 2){
8042 BrHXXRatio = (myNPbase->BrHgagaRatio());
8043 dBrHXXRatio1 = BrHXXRatio - 1.0;
8044 dBrHXXRatio2 = 0.0;
8045 } else if (fstate == 3){
8046 BrHXXRatio = (myNPbase->BrHbbRatio());
8047 dBrHXXRatio1 = BrHXXRatio - 1.0;
8048 dBrHXXRatio2 = 0.0;
8049 } else if (fstate == 4){
8050 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8051 dBrHXXRatio1 = BrHXXRatio - 1.0;
8052 dBrHXXRatio2 = 0.0;
8053 } else if (fstate == 5){
8054 BrHXXRatio = (myNPbase->BrHtautauRatio());
8055 dBrHXXRatio1 = BrHXXRatio - 1.0;
8056 dBrHXXRatio2 = 0.0;
8057 } else if (fstate == 6){
8058 BrHXXRatio = (myNPbase->BrHWWRatio());
8059 dBrHXXRatio1 = BrHXXRatio - 1.0;
8060 dBrHXXRatio2 = 0.0;
8061 } else if (fstate == 7){
8062 BrHXXRatio = (myNPbase->BrHZZRatio());
8063 dBrHXXRatio1 = BrHXXRatio - 1.0;
8064 dBrHXXRatio2 = 0.0;
8065 } else {
8066 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
8067 }
8068
8069 //-- Production x Decay:
8070 if ((this->getModel()).isModelLinearized()){
8071 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8072 } else if((this->getModel()).isModelNPquadratic()){
8073 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8074 } else {
8075 return weight*(muProd)*(BrHXXRatio);
8076 }
8077}
8078
8079
8080
8081
8082
8083// -----------------------------------------------------------------------------
8084
8085//VM:STXS2024;
8086STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8087: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8088{
8089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8090 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
8091
8092}
8093
8095{
8096 //-- Production:
8097 double weight = 1.0; //If normalized to the SM
8098 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8099
8100 double muProd = ((1.24)*(myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
8102 /(1.24+2.00);
8103 double muProd1 = muProd -1.0;
8104 double muProd2 = 0.0;
8105
8106 //-- Decay:
8107 double BrHXXRatio = 1.0;
8108 double dBrHXXRatio1 = 0.0;
8109 double dBrHXXRatio2 = 0.0;
8110 if (fstate==0){
8111 // Use for Cross-section [pb] with no Higgs-boson decay
8112 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8113 //This weight is a bit smaller than the sum of the weights considered for the two bins that
8114 //generate this bin when combined 1.24+2.00=3.24, This is because the values have been obtained
8115 //from different papers and they give slightly different predictions. However, the uncertainty
8116 //given by the ATLAS paper that combines the bins is of 0.6 pb for the SM prediction, above the
8117 //difference that we find with the other SM prediction so it is fine.
8118 } else if (fstate == 1){
8119 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8120 dBrHXXRatio1 = BrHXXRatio - 1.0;
8121 dBrHXXRatio2 = 0.0;
8122 } else if (fstate == 2){
8123 BrHXXRatio = (myNPbase->BrHgagaRatio());
8124 dBrHXXRatio1 = BrHXXRatio - 1.0;
8125 dBrHXXRatio2 = 0.0;
8126 } else if (fstate == 3){
8127 BrHXXRatio = (myNPbase->BrHbbRatio());
8128 dBrHXXRatio1 = BrHXXRatio - 1.0;
8129 dBrHXXRatio2 = 0.0;
8130 } else if (fstate == 4){
8131 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8132 dBrHXXRatio1 = BrHXXRatio - 1.0;
8133 dBrHXXRatio2 = 0.0;
8134 } else if (fstate == 5){
8135 BrHXXRatio = (myNPbase->BrHtautauRatio());
8136 dBrHXXRatio1 = BrHXXRatio - 1.0;
8137 dBrHXXRatio2 = 0.0;
8138 } else if (fstate == 6){
8139 BrHXXRatio = (myNPbase->BrHWWRatio());
8140 dBrHXXRatio1 = BrHXXRatio - 1.0;
8141 dBrHXXRatio2 = 0.0;
8142 } else if (fstate == 7){
8143 BrHXXRatio = (myNPbase->BrHZZRatio());
8144 dBrHXXRatio1 = BrHXXRatio - 1.0;
8145 dBrHXXRatio2 = 0.0;
8146 } else {
8147 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
8148 }
8149
8150 //-- Production x Decay:
8151 if ((this->getModel()).isModelLinearized()){
8152 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8153 } else if((this->getModel()).isModelNPquadratic()){
8154 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8155 } else {
8156 return weight*(muProd)*(BrHXXRatio);
8157 }
8158
8159}
8160
8161
8162
8163
8164// -----------------------------------------------------------------------------
8165
8166//AG:STXS2024
8167STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8168: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8169{
8170 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8171 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
8172
8173}
8174
8176{
8177 //-- Production:
8178 double weight = 1.0; //If normalized to the SM
8180 double muProd1 = muProd -1.0;
8181 double muProd2 = 0.0;
8182
8183 //-- Decay:
8184 double BrHXXRatio = 1.0;
8185 double dBrHXXRatio1 = 0.0;
8186 double dBrHXXRatio2 = 0.0;
8187 if (fstate==0){
8188 // Use for Cross-section [pb] with no Higgs-boson decay
8189 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8190 } else if (fstate == 1){
8191 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8192 dBrHXXRatio1 = BrHXXRatio - 1.0;
8193 dBrHXXRatio2 = 0.0;
8194 } else if (fstate == 2){
8195 BrHXXRatio = (myNPbase->BrHgagaRatio());
8196 dBrHXXRatio1 = BrHXXRatio - 1.0;
8197 dBrHXXRatio2 = 0.0;
8198 } else if (fstate == 3){
8199 BrHXXRatio = (myNPbase->BrHbbRatio());
8200 dBrHXXRatio1 = BrHXXRatio - 1.0;
8201 dBrHXXRatio2 = 0.0;
8202 } else if (fstate == 4){
8203 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8204 dBrHXXRatio1 = BrHXXRatio - 1.0;
8205 dBrHXXRatio2 = 0.0;
8206 } else if (fstate == 5){
8207 BrHXXRatio = (myNPbase->BrHtautauRatio());
8208 dBrHXXRatio1 = BrHXXRatio - 1.0;
8209 dBrHXXRatio2 = 0.0;
8210 } else if (fstate == 6){
8211 BrHXXRatio = (myNPbase->BrHWWRatio());
8212 dBrHXXRatio1 = BrHXXRatio - 1.0;
8213 dBrHXXRatio2 = 0.0;
8214 } else if (fstate == 7){
8215 BrHXXRatio = (myNPbase->BrHZZRatio());
8216 dBrHXXRatio1 = BrHXXRatio - 1.0;
8217 dBrHXXRatio2 = 0.0;
8218 } else {
8219 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
8220 }
8221
8222 //-- Production x Decay:
8223 if ((this->getModel()).isModelLinearized()){
8224 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8225 } else if((this->getModel()).isModelNPquadratic()){
8226 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8227 } else {
8228 return weight*(muProd)*(BrHXXRatio);
8229 }
8230
8231}
8232
8233
8234
8235
8236//VM:STXS2024;
8237STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8238: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8239{
8240 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8241 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8242
8243}
8244
8246{
8247 //-- Production:
8248 double weight = 1.0; //If normalized to the SM
8249 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8250 //We should weight each xsection with the SM prediction. We need to check
8251 //this values, nevertheless, the difference between the two parametrisations
8252 //is extremely small (way beyond our current precision)
8255 /(2.);
8256 double muProd1 = muProd -1.0;
8257 double muProd2 = 0.0;
8258
8259 //-- Decay:
8260 double BrHXXRatio = 1.0;
8261 double dBrHXXRatio1 = 0.0;
8262 double dBrHXXRatio2 = 0.0;
8263 if (fstate==0){
8264 // Use for Cross-section [pb] with no Higgs-boson decay
8265 weight = (0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8266 } else if (fstate == 1){
8267 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8268 dBrHXXRatio1 = BrHXXRatio - 1.0;
8269 dBrHXXRatio2 = 0.0;
8270 } else if (fstate == 2){
8271 BrHXXRatio = (myNPbase->BrHgagaRatio());
8272 dBrHXXRatio1 = BrHXXRatio - 1.0;
8273 dBrHXXRatio2 = 0.0;
8274 } else if (fstate == 3){
8275 BrHXXRatio = (myNPbase->BrHbbRatio());
8276 dBrHXXRatio1 = BrHXXRatio - 1.0;
8277 dBrHXXRatio2 = 0.0;
8278 } else if (fstate == 4){
8279 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8280 dBrHXXRatio1 = BrHXXRatio - 1.0;
8281 dBrHXXRatio2 = 0.0;
8282 } else if (fstate == 5){
8283 BrHXXRatio = (myNPbase->BrHtautauRatio());
8284 dBrHXXRatio1 = BrHXXRatio - 1.0;
8285 dBrHXXRatio2 = 0.0;
8286 } else if (fstate == 6){
8287 BrHXXRatio = (myNPbase->BrHWWRatio());
8288 dBrHXXRatio1 = BrHXXRatio - 1.0;
8289 dBrHXXRatio2 = 0.0;
8290 } else if (fstate == 7){
8291 BrHXXRatio = (myNPbase->BrHZZRatio());
8292 dBrHXXRatio1 = BrHXXRatio - 1.0;
8293 dBrHXXRatio2 = 0.0;
8294 } else {
8295 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8296 }
8297
8298 //-- Production x Decay:
8299 if ((this->getModel()).isModelLinearized()){
8300 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8301 } else if((this->getModel()).isModelNPquadratic()){
8302 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8303 } else {
8304 return weight*(muProd)*(BrHXXRatio);
8305 }
8306
8307}
8308
8309
8310// -----------------------------------------------------------------------------
8311
8313: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8314{
8315 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8316 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8317
8318}
8319
8321{
8322 double BrHXXRatio = 1.0;
8323 if (fstate == 1){
8324 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8325 } else if (fstate == 2){
8326 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8327 } else if (fstate == 3){
8328 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8329 } else if (fstate == 4){
8330 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8331 } else {
8332 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8333 }
8334
8335 if ((this->getModel()).isModelLinearized()) {
8336 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8337 } else {
8339 }
8340}
8341
8342// -----------------------------------------------------------------------------
8343
8345: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8346{
8347
8348 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8349 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8350
8351}
8352
8354{
8355 double BrHXXRatio = 1.0;
8356 if (fstate == 1){
8357 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8358 } else if (fstate == 2){
8359 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8360 } else if (fstate == 3){
8361 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8362 } else if (fstate == 4){
8363 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8364 } else {
8365 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8366 }
8367
8368 if ((this->getModel()).isModelLinearized()) {
8369 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8370 } else {
8372 }
8373}
8374
8375// -----------------------------------------------------------------------------
8376
8378: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8379{
8380 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8381 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8382
8383}
8384
8386{
8387 double BrHXXRatio = 1.0;
8388 if (fstate == 1){
8389 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8390 } else if (fstate == 2){
8391 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8392 } else if (fstate == 3){
8393 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8394 } else if (fstate == 4){
8395 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8396 } else {
8397 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8398 }
8399
8400 if ((this->getModel()).isModelLinearized()) {
8401 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8402 } else {
8404 }
8405}
8406
8407// -----------------------------------------------------------------------------
8408
8410: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8411{
8412 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8413 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8414
8415}
8416
8418{
8419 double BrHXXRatio = 1.0;
8420 if (fstate == 1){
8421 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8422 } else if (fstate == 2){
8423 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8424 } else if (fstate == 3){
8425 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8426 } else if (fstate == 4){
8427 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8428 } else {
8429 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8430 }
8431
8432 if ((this->getModel()).isModelLinearized()) {
8433 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8434 } else {
8436 }
8437}
8438
8439
8440
8441
8442
8443// -----------------------------------------------------------------------------
8444
8445//VM:STXS2024;
8446STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8447: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8448{
8449 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8450 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8451
8452}
8453
8455{
8456
8457
8458
8459 //-- Production:
8460 double weight = 1.0; //If normalized to the SM
8461 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8462 //Ref: Also CMS note HIG-21-018-PAS-v3
8463 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8464 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8465 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8466 //The possible error that we could be introducing here is way below our precision!
8467 double muProd = (
8472 )/(1.24+2.00+0.94321+0.87751);
8473 double muProd1 = muProd -1.0;
8474 double muProd2 = 0.0;
8475
8476 //-- Decay:
8477 double BrHXXRatio = 1.0;
8478 double dBrHXXRatio1 = 0.0;
8479 double dBrHXXRatio2 = 0.0;
8480 if (fstate==0){
8481 // Use for Cross-section [pb] with no Higgs-boson decay
8482 weight = (1.24+2.00+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8483 } else if (fstate == 1){
8484 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8485 dBrHXXRatio1 = BrHXXRatio - 1.0;
8486 dBrHXXRatio2 = 0.0;
8487 } else if (fstate == 2){
8488 BrHXXRatio = (myNPbase->BrHgagaRatio());
8489 dBrHXXRatio1 = BrHXXRatio - 1.0;
8490 dBrHXXRatio2 = 0.0;
8491 } else if (fstate == 3){
8492 BrHXXRatio = (myNPbase->BrHbbRatio());
8493 dBrHXXRatio1 = BrHXXRatio - 1.0;
8494 dBrHXXRatio2 = 0.0;
8495 } else if (fstate == 4){
8496 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8497 dBrHXXRatio1 = BrHXXRatio - 1.0;
8498 dBrHXXRatio2 = 0.0;
8499 } else if (fstate == 5){
8500 BrHXXRatio = (myNPbase->BrHtautauRatio());
8501 dBrHXXRatio1 = BrHXXRatio - 1.0;
8502 dBrHXXRatio2 = 0.0;
8503 } else if (fstate == 6){
8504 BrHXXRatio = (myNPbase->BrHWWRatio());
8505 dBrHXXRatio1 = BrHXXRatio - 1.0;
8506 dBrHXXRatio2 = 0.0;
8507 } else if (fstate == 7){
8508 BrHXXRatio = (myNPbase->BrHZZRatio());
8509 dBrHXXRatio1 = BrHXXRatio - 1.0;
8510 dBrHXXRatio2 = 0.0;
8511 } else {
8512 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8513 }
8514
8515 //-- Production x Decay:
8516 if ((this->getModel()).isModelLinearized()){
8517 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8518 } else if((this->getModel()).isModelNPquadratic()){
8519 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8520 } else {
8521 return weight*(muProd)*(BrHXXRatio);
8522 }
8523
8524}
8525
8526
8527
8528
8529
8530
8531
8532// -----------------------------------------------------------------------------
8533
8534
8535//VM:STXS2024;
8536STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8537: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8538{
8539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8540 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8541
8542}
8543
8545{
8546 //-- Production:
8547 double weight = 1.0; //If normalized to the SM
8548 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8549 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8552 /(0.45825 + 0.10632 + 0.017974);
8553 double muProd1 = muProd -1.0;
8554 double muProd2 = 0.0;
8555
8556 //-- Decay:
8557 double BrHXXRatio = 1.0;
8558 double dBrHXXRatio1 = 0.0;
8559 double dBrHXXRatio2 = 0.0;
8560 if (fstate==0){
8561 // Use for Cross-section [pb] with no Higgs-boson decay
8562 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8563 } else if (fstate == 1){
8564 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8565 dBrHXXRatio1 = BrHXXRatio - 1.0;
8566 dBrHXXRatio2 = 0.0;
8567 } else if (fstate == 2){
8568 BrHXXRatio = (myNPbase->BrHgagaRatio());
8569 dBrHXXRatio1 = BrHXXRatio - 1.0;
8570 dBrHXXRatio2 = 0.0;
8571 } else if (fstate == 3){
8572 BrHXXRatio = (myNPbase->BrHbbRatio());
8573 dBrHXXRatio1 = BrHXXRatio - 1.0;
8574 dBrHXXRatio2 = 0.0;
8575 } else if (fstate == 4){
8576 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8577 dBrHXXRatio1 = BrHXXRatio - 1.0;
8578 dBrHXXRatio2 = 0.0;
8579 } else if (fstate == 5){
8580 BrHXXRatio = (myNPbase->BrHtautauRatio());
8581 dBrHXXRatio1 = BrHXXRatio - 1.0;
8582 dBrHXXRatio2 = 0.0;
8583 } else if (fstate == 6){
8584 BrHXXRatio = (myNPbase->BrHWWRatio());
8585 dBrHXXRatio1 = BrHXXRatio - 1.0;
8586 dBrHXXRatio2 = 0.0;
8587 } else if (fstate == 7){
8588 BrHXXRatio = (myNPbase->BrHZZRatio());
8589 dBrHXXRatio1 = BrHXXRatio - 1.0;
8590 dBrHXXRatio2 = 0.0;
8591 } else {
8592 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8593 }
8594
8595 //-- Production x Decay:
8596 if ((this->getModel()).isModelLinearized()){
8597 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8598 } else if((this->getModel()).isModelNPquadratic()){
8599 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8600 } else {
8601 return weight*(muProd)*(BrHXXRatio);
8602 }
8603
8604}
8605
8606
8607
8608
8609// -----------------------------------------------------------------------------
8610
8611
8612//VM:STXS2024;
8613STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8614: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8615{
8616 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8617 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8618
8619}
8620
8622{
8623 //-- Production:
8624 double weight = 1.0; //If normalized to the SM
8625 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8626 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8628 /(0.10632 + 0.017974);
8629 double muProd1 = muProd -1.0;
8630 double muProd2 = 0.0;
8631
8632 //-- Decay:
8633 double BrHXXRatio = 1.0;
8634 double dBrHXXRatio1 = 0.0;
8635 double dBrHXXRatio2 = 0.0;
8636 if (fstate==0){
8637 // Use for Cross-section [pb] with no Higgs-boson decay
8638 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8639 } else if (fstate == 1){
8640 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8641 dBrHXXRatio1 = BrHXXRatio - 1.0;
8642 dBrHXXRatio2 = 0.0;
8643 } else if (fstate == 2){
8644 BrHXXRatio = (myNPbase->BrHgagaRatio());
8645 dBrHXXRatio1 = BrHXXRatio - 1.0;
8646 dBrHXXRatio2 = 0.0;
8647 } else if (fstate == 3){
8648 BrHXXRatio = (myNPbase->BrHbbRatio());
8649 dBrHXXRatio1 = BrHXXRatio - 1.0;
8650 dBrHXXRatio2 = 0.0;
8651 } else if (fstate == 4){
8652 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8653 dBrHXXRatio1 = BrHXXRatio - 1.0;
8654 dBrHXXRatio2 = 0.0;
8655 } else if (fstate == 5){
8656 BrHXXRatio = (myNPbase->BrHtautauRatio());
8657 dBrHXXRatio1 = BrHXXRatio - 1.0;
8658 dBrHXXRatio2 = 0.0;
8659 } else if (fstate == 6){
8660 BrHXXRatio = (myNPbase->BrHWWRatio());
8661 dBrHXXRatio1 = BrHXXRatio - 1.0;
8662 dBrHXXRatio2 = 0.0;
8663 } else if (fstate == 7){
8664 BrHXXRatio = (myNPbase->BrHZZRatio());
8665 dBrHXXRatio1 = BrHXXRatio - 1.0;
8666 dBrHXXRatio2 = 0.0;
8667 } else {
8668 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8669 }
8670
8671 //-- Production x Decay:
8672 if ((this->getModel()).isModelLinearized()){
8673 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8674 } else if((this->getModel()).isModelNPquadratic()){
8675 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8676 } else {
8677 return weight*(muProd)*(BrHXXRatio);
8678 }
8679
8680}
8681
8682
8683// -----------------------------------------------------------------------------
8684
8685
8686//VM:STXS2024;
8687STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8688: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8689{
8690 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8691 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8692
8693}
8694
8696{
8697 //-- Production:
8698 double weight = 1.0; //If normalized to the SM
8699 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8700 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8701 double muProd1 = muProd -1.0;
8702 double muProd2 = 0.0;
8703
8704 //-- Decay:
8705 double BrHXXRatio = 1.0;
8706 double dBrHXXRatio1 = 0.0;
8707 double dBrHXXRatio2 = 0.0;
8708 if (fstate==0){
8709 // Use for Cross-section [pb] with no Higgs-boson decay
8710 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8711 } else if (fstate == 1){
8712 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8713 dBrHXXRatio1 = BrHXXRatio - 1.0;
8714 dBrHXXRatio2 = 0.0;
8715 } else if (fstate == 2){
8716 BrHXXRatio = (myNPbase->BrHgagaRatio());
8717 dBrHXXRatio1 = BrHXXRatio - 1.0;
8718 dBrHXXRatio2 = 0.0;
8719 } else if (fstate == 3){
8720 BrHXXRatio = (myNPbase->BrHbbRatio());
8721 dBrHXXRatio1 = BrHXXRatio - 1.0;
8722 dBrHXXRatio2 = 0.0;
8723 } else if (fstate == 4){
8724 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8725 dBrHXXRatio1 = BrHXXRatio - 1.0;
8726 dBrHXXRatio2 = 0.0;
8727 } else if (fstate == 5){
8728 BrHXXRatio = (myNPbase->BrHtautauRatio());
8729 dBrHXXRatio1 = BrHXXRatio - 1.0;
8730 dBrHXXRatio2 = 0.0;
8731 } else if (fstate == 6){
8732 BrHXXRatio = (myNPbase->BrHWWRatio());
8733 dBrHXXRatio1 = BrHXXRatio - 1.0;
8734 dBrHXXRatio2 = 0.0;
8735 } else if (fstate == 7){
8736 BrHXXRatio = (myNPbase->BrHZZRatio());
8737 dBrHXXRatio1 = BrHXXRatio - 1.0;
8738 dBrHXXRatio2 = 0.0;
8739 } else {
8740 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8741 }
8742
8743 //-- Production x Decay:
8744 if ((this->getModel()).isModelLinearized()){
8745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8746 } else if((this->getModel()).isModelNPquadratic()){
8747 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8748 } else {
8749 return weight*(muProd)*(BrHXXRatio);
8750 }
8751
8752}
8753
8754
8755
8756// -----------------------------------------------------------------------------
8757
8758
8759//VM:STXS2024;
8760STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8761: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8762{
8763 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8764 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8765
8766}
8767
8769{
8770 //-- Production:
8771 double weight = 1.0; //If normalized to the SM
8772 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8773 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8774 double muProd1 = muProd -1.0;
8775 double muProd2 = 0.0;
8776
8777 //-- Decay:
8778 double BrHXXRatio = 1.0;
8779 double dBrHXXRatio1 = 0.0;
8780 double dBrHXXRatio2 = 0.0;
8781 if (fstate==0){
8782 // Use for Cross-section [pb] with no Higgs-boson decay
8783 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8784 } else if (fstate == 1){
8785 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8786 dBrHXXRatio1 = BrHXXRatio - 1.0;
8787 dBrHXXRatio2 = 0.0;
8788 } else if (fstate == 2){
8789 BrHXXRatio = (myNPbase->BrHgagaRatio());
8790 dBrHXXRatio1 = BrHXXRatio - 1.0;
8791 dBrHXXRatio2 = 0.0;
8792 } else if (fstate == 3){
8793 BrHXXRatio = (myNPbase->BrHbbRatio());
8794 dBrHXXRatio1 = BrHXXRatio - 1.0;
8795 dBrHXXRatio2 = 0.0;
8796 } else if (fstate == 4){
8797 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8798 dBrHXXRatio1 = BrHXXRatio - 1.0;
8799 dBrHXXRatio2 = 0.0;
8800 } else if (fstate == 5){
8801 BrHXXRatio = (myNPbase->BrHtautauRatio());
8802 dBrHXXRatio1 = BrHXXRatio - 1.0;
8803 dBrHXXRatio2 = 0.0;
8804 } else if (fstate == 6){
8805 BrHXXRatio = (myNPbase->BrHWWRatio());
8806 dBrHXXRatio1 = BrHXXRatio - 1.0;
8807 dBrHXXRatio2 = 0.0;
8808 } else if (fstate == 7){
8809 BrHXXRatio = (myNPbase->BrHZZRatio());
8810 dBrHXXRatio1 = BrHXXRatio - 1.0;
8811 dBrHXXRatio2 = 0.0;
8812 } else {
8813 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8814 }
8815
8816 //-- Production x Decay:
8817 if ((this->getModel()).isModelLinearized()){
8818 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8819 } else if((this->getModel()).isModelNPquadratic()){
8820 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8821 } else {
8822 return weight*(muProd)*(BrHXXRatio);
8823 }
8824
8825}
8826
8827
8828
8829
8830// -----------------------------------------------------------------------------
8831
8832
8833//VM:STXS2024;
8834STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8835: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8836{
8837 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8838 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8839
8840}
8841
8843{
8844 //-- Production:
8845 double weight = 1.0; //If normalized to the SM
8846 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8847 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8848 double muProd1 = muProd -1.0;
8849 double muProd2 = 0.0;
8850
8851 //-- Decay:
8852 double BrHXXRatio = 1.0;
8853 double dBrHXXRatio1 = 0.0;
8854 double dBrHXXRatio2 = 0.0;
8855 if (fstate==0){
8856 // Use for Cross-section [pb] with no Higgs-boson decay
8857 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8858 } else if (fstate == 1){
8859 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8860 dBrHXXRatio1 = BrHXXRatio - 1.0;
8861 dBrHXXRatio2 = 0.0;
8862 } else if (fstate == 2){
8863 BrHXXRatio = (myNPbase->BrHgagaRatio());
8864 dBrHXXRatio1 = BrHXXRatio - 1.0;
8865 dBrHXXRatio2 = 0.0;
8866 } else if (fstate == 3){
8867 BrHXXRatio = (myNPbase->BrHbbRatio());
8868 dBrHXXRatio1 = BrHXXRatio - 1.0;
8869 dBrHXXRatio2 = 0.0;
8870 } else if (fstate == 4){
8871 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8872 dBrHXXRatio1 = BrHXXRatio - 1.0;
8873 dBrHXXRatio2 = 0.0;
8874 } else if (fstate == 5){
8875 BrHXXRatio = (myNPbase->BrHtautauRatio());
8876 dBrHXXRatio1 = BrHXXRatio - 1.0;
8877 dBrHXXRatio2 = 0.0;
8878 } else if (fstate == 6){
8879 BrHXXRatio = (myNPbase->BrHWWRatio());
8880 dBrHXXRatio1 = BrHXXRatio - 1.0;
8881 dBrHXXRatio2 = 0.0;
8882 } else if (fstate == 7){
8883 BrHXXRatio = (myNPbase->BrHZZRatio());
8884 dBrHXXRatio1 = BrHXXRatio - 1.0;
8885 dBrHXXRatio2 = 0.0;
8886 } else {
8887 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8888 }
8889
8890 //-- Production x Decay:
8891 if ((this->getModel()).isModelLinearized()){
8892 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8893 } else if((this->getModel()).isModelNPquadratic()){
8894 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8895 } else {
8896 return weight*(muProd)*(BrHXXRatio);
8897 }
8898
8899}
8900
8901
8902
8903// -----------------------------------------------------------------------------
8904
8905
8906//VM:STXS2024;
8907STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8908: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8909{
8910 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8911 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8912
8913}
8914
8916{
8917 //-- Production:
8918 double weight = 1.0; //If normalized to the SM
8919 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8920 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8921 double muProd1 = muProd -1.0;
8922 double muProd2 = 0.0;
8923
8924 //-- Decay:
8925 double BrHXXRatio = 1.0;
8926 double dBrHXXRatio1 = 0.0;
8927 double dBrHXXRatio2 = 0.0;
8928 if (fstate==0){
8929 // Use for Cross-section [pb] with no Higgs-boson decay
8930 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8931 } else if (fstate == 1){
8932 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8933 dBrHXXRatio1 = BrHXXRatio - 1.0;
8934 dBrHXXRatio2 = 0.0;
8935 } else if (fstate == 2){
8936 BrHXXRatio = (myNPbase->BrHgagaRatio());
8937 dBrHXXRatio1 = BrHXXRatio - 1.0;
8938 dBrHXXRatio2 = 0.0;
8939 } else if (fstate == 3){
8940 BrHXXRatio = (myNPbase->BrHbbRatio());
8941 dBrHXXRatio1 = BrHXXRatio - 1.0;
8942 dBrHXXRatio2 = 0.0;
8943 } else if (fstate == 4){
8944 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8945 dBrHXXRatio1 = BrHXXRatio - 1.0;
8946 dBrHXXRatio2 = 0.0;
8947 } else if (fstate == 5){
8948 BrHXXRatio = (myNPbase->BrHtautauRatio());
8949 dBrHXXRatio1 = BrHXXRatio - 1.0;
8950 dBrHXXRatio2 = 0.0;
8951 } else if (fstate == 6){
8952 BrHXXRatio = (myNPbase->BrHWWRatio());
8953 dBrHXXRatio1 = BrHXXRatio - 1.0;
8954 dBrHXXRatio2 = 0.0;
8955 } else if (fstate == 7){
8956 BrHXXRatio = (myNPbase->BrHZZRatio());
8957 dBrHXXRatio1 = BrHXXRatio - 1.0;
8958 dBrHXXRatio2 = 0.0;
8959 } else {
8960 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8961 }
8962
8963 //-- Production x Decay:
8964 if ((this->getModel()).isModelLinearized()){
8965 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8966 } else if((this->getModel()).isModelNPquadratic()){
8967 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8968 } else {
8969 return weight*(muProd)*(BrHXXRatio);
8970 }
8971
8972}
8973
8974
8975
8976// -----------------------------------------------------------------------------
8977
8978
8979//VM:STXS2024;
8980STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8981: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8982{
8983 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8984 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8985
8986}
8987
8989{
8990 //-- Production:
8991 double weight = 1.0; //If normalized to the SM
8992 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8993 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8994 double muProd1 = muProd -1.0;
8995 double muProd2 = 0.0;
8996
8997 //-- Decay:
8998 double BrHXXRatio = 1.0;
8999 double dBrHXXRatio1 = 0.0;
9000 double dBrHXXRatio2 = 0.0;
9001 if (fstate==0){
9002 // Use for Cross-section [pb] with no Higgs-boson decay
9003 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9004 } else if (fstate == 1){
9005 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9006 dBrHXXRatio1 = BrHXXRatio - 1.0;
9007 dBrHXXRatio2 = 0.0;
9008 } else if (fstate == 2){
9009 BrHXXRatio = (myNPbase->BrHgagaRatio());
9010 dBrHXXRatio1 = BrHXXRatio - 1.0;
9011 dBrHXXRatio2 = 0.0;
9012 } else if (fstate == 3){
9013 BrHXXRatio = (myNPbase->BrHbbRatio());
9014 dBrHXXRatio1 = BrHXXRatio - 1.0;
9015 dBrHXXRatio2 = 0.0;
9016 } else if (fstate == 4){
9017 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9018 dBrHXXRatio1 = BrHXXRatio - 1.0;
9019 dBrHXXRatio2 = 0.0;
9020 } else if (fstate == 5){
9021 BrHXXRatio = (myNPbase->BrHtautauRatio());
9022 dBrHXXRatio1 = BrHXXRatio - 1.0;
9023 dBrHXXRatio2 = 0.0;
9024 } else if (fstate == 6){
9025 BrHXXRatio = (myNPbase->BrHWWRatio());
9026 dBrHXXRatio1 = BrHXXRatio - 1.0;
9027 dBrHXXRatio2 = 0.0;
9028 } else if (fstate == 7){
9029 BrHXXRatio = (myNPbase->BrHZZRatio());
9030 dBrHXXRatio1 = BrHXXRatio - 1.0;
9031 dBrHXXRatio2 = 0.0;
9032 } else {
9033 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
9034 }
9035
9036 //-- Production x Decay:
9037 if ((this->getModel()).isModelLinearized()){
9038 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9039 } else if((this->getModel()).isModelNPquadratic()){
9040 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9041 } else {
9042 return weight*(muProd)*(BrHXXRatio);
9043 }
9044
9045}
9046
9047
9048// -----------------------------------------------------------------------------
9049
9050STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9051: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9052{
9053 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9054 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
9055
9056}
9057
9059{
9060 double BrHXXRatio = 1.0;
9061 if (fstate == 1){
9062 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9063 } else if (fstate == 2){
9064 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9065 } else if (fstate == 3){
9066 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9067 } else if (fstate == 4){
9068 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9069 } else {
9070 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
9071 }
9072
9073 if ((this->getModel()).isModelLinearized()) {
9074 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
9075 } else {
9076 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
9077 }
9078}
9079
9080// -----------------------------------------------------------------------------
9081
9082STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9083: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9084{
9085 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9086 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
9087
9088}
9089
9091{
9092 double BrHXXRatio = 1.0;
9093 if (fstate == 1){
9094 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9095 } else if (fstate == 2){
9096 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9097 } else if (fstate == 3){
9098 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9099 } else if (fstate == 4){
9100 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9101 } else {
9102 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
9103 }
9104
9105 if ((this->getModel()).isModelLinearized()) {
9106 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
9107 } else {
9108 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
9109 }
9110}
9111
9112// -----------------------------------------------------------------------------
9113
9114STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9115: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9116{
9117 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9118 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
9119
9120}
9121
9123{
9124 double BrHXXRatio = 1.0;
9125 if (fstate == 1){
9126 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9127 } else if (fstate == 2){
9128 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9129 } else if (fstate == 3){
9130 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9131 } else if (fstate == 4){
9132 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9133 } else {
9134 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
9135 }
9136
9137 if ((this->getModel()).isModelLinearized()) {
9138 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
9139 } else {
9140 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
9141 }
9142}
9143
9144// -----------------------------------------------------------------------------
9145
9146STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9147: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9148{
9149 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9150 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
9151
9152}
9153
9155{
9156 double BrHXXRatio = 1.0;
9157 if (fstate == 1){
9158 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9159 } else if (fstate == 2){
9160 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9161 } else if (fstate == 3){
9162 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9163 } else if (fstate == 4){
9164 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9165 } else {
9166 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
9167 }
9168
9169 if ((this->getModel()).isModelLinearized()) {
9170 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
9171 } else {
9172 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
9173 }
9174}
9175
9176// -----------------------------------------------------------------------------
9177
9178STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9179: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9180{
9181 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9182 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
9183
9184}
9185
9187{
9188 double BrHXXRatio = 1.0;
9189 if (fstate == 1){
9190 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9191 } else if (fstate == 2){
9192 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9193 } else if (fstate == 3){
9194 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9195 } else if (fstate == 4){
9196 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9197 } else {
9198 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
9199 }
9200
9201 if ((this->getModel()).isModelLinearized()) {
9202 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
9203 } else {
9204 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
9205 }
9206}
9207
9208// -----------------------------------------------------------------------------
9209
9210STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9211: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9212{
9213 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9214 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
9215
9216}
9217
9219{
9220 double BrHXXRatio = 1.0;
9221 if (fstate == 1){
9222 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9223 } else if (fstate == 2){
9224 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9225 } else if (fstate == 3){
9226 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9227 } else if (fstate == 4){
9228 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9229 } else {
9230 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
9231 }
9232
9233 if ((this->getModel()).isModelLinearized()) {
9234 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
9235 } else {
9236 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
9237 }
9238}
9239
9240// -----------------------------------------------------------------------------
9241
9242STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9243: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9244{
9245 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9246 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
9247
9248}
9249
9251{
9252 double BrHXXRatio = 1.0;
9253 if (fstate == 1){
9254 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9255 } else if (fstate == 2){
9256 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9257 } else if (fstate == 3){
9258 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9259 } else if (fstate == 4){
9260 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9261 } else {
9262 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
9263 }
9264
9265 if ((this->getModel()).isModelLinearized()) {
9266 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
9267 } else {
9268 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
9269 }
9270}
9271
9272// -----------------------------------------------------------------------------
9273
9274STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9275: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9276{
9277 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9278 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
9279
9280}
9281
9283{
9284 double BrHXXRatio = 1.0;
9285 if (fstate == 1){
9286 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9287 } else if (fstate == 2){
9288 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9289 } else if (fstate == 3){
9290 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9291 } else if (fstate == 4){
9292 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9293 } else {
9294 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
9295 }
9296
9297 if ((this->getModel()).isModelLinearized()) {
9298 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9299 } else {
9300 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
9301 }
9302}
9303
9304
9305
9306// -----------------------------------------------------------------------------
9307
9308
9309//VM:STXS2024;
9310STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9311: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9312{
9313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9314 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
9315
9316}
9317
9319{
9320 //-- Production:
9321 double weight = 1.0; //If normalized to the SM
9322 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9323 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
9324 double muProd1 = muProd -1.0;
9325 double muProd2 = 0.0;
9326
9327 //-- Decay:
9328 double BrHXXRatio = 1.0;
9329 double dBrHXXRatio1 = 0.0;
9330 double dBrHXXRatio2 = 0.0;
9331 if (fstate==0){
9332 // Use for Cross-section [pb] with no Higgs-boson decay
9333 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9334 } else if (fstate == 1){
9335 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9336 dBrHXXRatio1 = BrHXXRatio - 1.0;
9337 dBrHXXRatio2 = 0.0;
9338 } else if (fstate == 2){
9339 BrHXXRatio = (myNPbase->BrHgagaRatio());
9340 dBrHXXRatio1 = BrHXXRatio - 1.0;
9341 dBrHXXRatio2 = 0.0;
9342 } else if (fstate == 3){
9343 BrHXXRatio = (myNPbase->BrHbbRatio());
9344 dBrHXXRatio1 = BrHXXRatio - 1.0;
9345 dBrHXXRatio2 = 0.0;
9346 } else if (fstate == 4){
9347 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9348 dBrHXXRatio1 = BrHXXRatio - 1.0;
9349 dBrHXXRatio2 = 0.0;
9350 } else if (fstate == 5){
9351 BrHXXRatio = (myNPbase->BrHtautauRatio());
9352 dBrHXXRatio1 = BrHXXRatio - 1.0;
9353 dBrHXXRatio2 = 0.0;
9354 } else if (fstate == 6){
9355 BrHXXRatio = (myNPbase->BrHWWRatio());
9356 dBrHXXRatio1 = BrHXXRatio - 1.0;
9357 dBrHXXRatio2 = 0.0;
9358 } else if (fstate == 7){
9359 BrHXXRatio = (myNPbase->BrHZZRatio());
9360 dBrHXXRatio1 = BrHXXRatio - 1.0;
9361 dBrHXXRatio2 = 0.0;
9362 } else {
9363 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9364 }
9365
9366 //-- Production x Decay:
9367 if ((this->getModel()).isModelLinearized()){
9368 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9369 } else if((this->getModel()).isModelNPquadratic()){
9370 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9371 } else {
9372 return weight*(muProd)*(BrHXXRatio);
9373 }
9374
9375}
9376
9377
9378
9379
9380// -----------------------------------------------------------------------------
9381
9382
9383//VM:STXS2024;
9384STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9385: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9386{
9387 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9388 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
9389
9390}
9391
9393{
9394 //-- Production:
9395 double weight = 1.0; //If normalized to the SM
9396 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9397 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
9398 double muProd1 = muProd -1.0;
9399 double muProd2 = 0.0;
9400
9401 //-- Decay:
9402 double BrHXXRatio = 1.0;
9403 double dBrHXXRatio1 = 0.0;
9404 double dBrHXXRatio2 = 0.0;
9405 if (fstate==0){
9406 // Use for Cross-section [pb] with no Higgs-boson decay
9407 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9408 } else if (fstate == 1){
9409 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9410 dBrHXXRatio1 = BrHXXRatio - 1.0;
9411 dBrHXXRatio2 = 0.0;
9412 } else if (fstate == 2){
9413 BrHXXRatio = (myNPbase->BrHgagaRatio());
9414 dBrHXXRatio1 = BrHXXRatio - 1.0;
9415 dBrHXXRatio2 = 0.0;
9416 } else if (fstate == 3){
9417 BrHXXRatio = (myNPbase->BrHbbRatio());
9418 dBrHXXRatio1 = BrHXXRatio - 1.0;
9419 dBrHXXRatio2 = 0.0;
9420 } else if (fstate == 4){
9421 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9422 dBrHXXRatio1 = BrHXXRatio - 1.0;
9423 dBrHXXRatio2 = 0.0;
9424 } else if (fstate == 5){
9425 BrHXXRatio = (myNPbase->BrHtautauRatio());
9426 dBrHXXRatio1 = BrHXXRatio - 1.0;
9427 dBrHXXRatio2 = 0.0;
9428 } else if (fstate == 6){
9429 BrHXXRatio = (myNPbase->BrHWWRatio());
9430 dBrHXXRatio1 = BrHXXRatio - 1.0;
9431 dBrHXXRatio2 = 0.0;
9432 } else if (fstate == 7){
9433 BrHXXRatio = (myNPbase->BrHZZRatio());
9434 dBrHXXRatio1 = BrHXXRatio - 1.0;
9435 dBrHXXRatio2 = 0.0;
9436 } else {
9437 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9438 }
9439
9440 //-- Production x Decay:
9441 if ((this->getModel()).isModelLinearized()){
9442 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9443 } else if((this->getModel()).isModelNPquadratic()){
9444 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9445 } else {
9446 return weight*(muProd)*(BrHXXRatio);
9447 }
9448
9449}
9450
9451
9452
9453// -----------------------------------------------------------------------------
9454
9455//AG:STXS2024
9456STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9457: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9458{
9459 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9460 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9461
9462}
9463
9465{
9466 //-- Production:
9467 double weight = 1.0; //If normalized to the SM
9468 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9469 double muProd1 = muProd -1.0;
9470 double muProd2 = 0.0;
9471
9472 //-- Decay:
9473 double BrHXXRatio = 1.0;
9474 double dBrHXXRatio1 = 0.0;
9475 double dBrHXXRatio2 = 0.0;
9476 if (fstate==0){
9477 // Use for Cross-section [pb] with no Higgs-boson decay
9478 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9479 } else if (fstate == 1){
9480 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9481 dBrHXXRatio1 = BrHXXRatio - 1.0;
9482 dBrHXXRatio2 = 0.0;
9483 } else if (fstate == 2){
9484 BrHXXRatio = (myNPbase->BrHgagaRatio());
9485 dBrHXXRatio1 = BrHXXRatio - 1.0;
9486 dBrHXXRatio2 = 0.0;
9487 } else if (fstate == 3){
9488 BrHXXRatio = (myNPbase->BrHbbRatio());
9489 dBrHXXRatio1 = BrHXXRatio - 1.0;
9490 dBrHXXRatio2 = 0.0;
9491 } else if (fstate == 4){
9492 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9493 dBrHXXRatio1 = BrHXXRatio - 1.0;
9494 dBrHXXRatio2 = 0.0;
9495 } else if (fstate == 5){
9496 BrHXXRatio = (myNPbase->BrHtautauRatio());
9497 dBrHXXRatio1 = BrHXXRatio - 1.0;
9498 dBrHXXRatio2 = 0.0;
9499 } else if (fstate == 6){
9500 BrHXXRatio = (myNPbase->BrHWWRatio());
9501 dBrHXXRatio1 = BrHXXRatio - 1.0;
9502 dBrHXXRatio2 = 0.0;
9503 } else if (fstate == 7){
9504 BrHXXRatio = (myNPbase->BrHZZRatio());
9505 dBrHXXRatio1 = BrHXXRatio - 1.0;
9506 dBrHXXRatio2 = 0.0;
9507 } else {
9508 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9509 }
9510
9511 //-- Production x Decay:
9512 if ((this->getModel()).isModelLinearized()){
9513 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9514 } else if((this->getModel()).isModelNPquadratic()){
9515 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9516 } else {
9517 return weight*(muProd)*(BrHXXRatio);
9518 }
9519}
9520
9521// -----------------------------------------------------------------------------
9522
9523STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9524: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9525{
9526 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9527 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9528
9529}
9530
9532{
9533 double BrHXXRatio = 1.0;
9534 if (fstate == 1){
9535 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9536 } else if (fstate == 2){
9537 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9538 } else if (fstate == 3){
9539 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9540 } else if (fstate == 4){
9541 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9542 } else {
9543 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9544 }
9545
9546 if ((this->getModel()).isModelLinearized()) {
9547 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9548 } else {
9549 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9550 }
9551}
9552
9553// -----------------------------------------------------------------------------
9554
9555//AG:STXS2024
9557: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9558{
9559 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9560 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9561
9562}
9563
9565{
9566 //-- Production:
9567 double weight = 1.0; //If normalized to the SM
9569 double muProd1 = muProd -1.0;
9570 double muProd2 = 0.0;
9571
9572 //-- Decay:
9573 double BrHXXRatio = 1.0;
9574 double dBrHXXRatio1 = 0.0;
9575 double dBrHXXRatio2 = 0.0;
9576 if (fstate==0){
9577 // Use for Cross-section [pb] with no Higgs-boson decay
9578 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9579 } else if (fstate == 1){
9580 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9581 dBrHXXRatio1 = BrHXXRatio - 1.0;
9582 dBrHXXRatio2 = 0.0;
9583 } else if (fstate == 2){
9584 BrHXXRatio = (myNPbase->BrHgagaRatio());
9585 dBrHXXRatio1 = BrHXXRatio - 1.0;
9586 dBrHXXRatio2 = 0.0;
9587 } else if (fstate == 3){
9588 BrHXXRatio = (myNPbase->BrHbbRatio());
9589 dBrHXXRatio1 = BrHXXRatio - 1.0;
9590 dBrHXXRatio2 = 0.0;
9591 } else if (fstate == 4){
9592 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9593 dBrHXXRatio1 = BrHXXRatio - 1.0;
9594 dBrHXXRatio2 = 0.0;
9595 } else if (fstate == 5){
9596 BrHXXRatio = (myNPbase->BrHtautauRatio());
9597 dBrHXXRatio1 = BrHXXRatio - 1.0;
9598 dBrHXXRatio2 = 0.0;
9599 } else if (fstate == 6){
9600 BrHXXRatio = (myNPbase->BrHWWRatio());
9601 dBrHXXRatio1 = BrHXXRatio - 1.0;
9602 dBrHXXRatio2 = 0.0;
9603 } else if (fstate == 7){
9604 BrHXXRatio = (myNPbase->BrHZZRatio());
9605 dBrHXXRatio1 = BrHXXRatio - 1.0;
9606 dBrHXXRatio2 = 0.0;
9607 } else {
9608 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9609 }
9610
9611
9612 //-- Production x Decay:
9613 if ((this->getModel()).isModelLinearized()){
9614 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9615 } else if((this->getModel()).isModelNPquadratic()){
9616 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9617 } else {
9618 return weight*(muProd)*(BrHXXRatio);
9619 }
9620
9621}
9622
9623// -----------------------------------------------------------------------------
9624
9625
9626
9627
9628
9629
9630
9632: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9633{
9634 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9635 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9636
9637}
9638
9640{
9641
9642 //-- Production:
9643 double weight = 1.0; //If normalized to the SM
9645 double muProd1 = muProd -1.0;
9646 double muProd2 = 0.0;
9647
9648 //-- Decay:
9649 double BrHXXRatio = 1.0;
9650 double dBrHXXRatio1 = 0.0;
9651 double dBrHXXRatio2 = 0.0;
9652 if (fstate==0){
9653 // Use for Cross-section [pb] with no Higgs-boson decay
9654 weight = 0.3948; //Ref: CMS-HIG-21-018-PAS-v3
9655 } else if (fstate == 1){
9656 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9657 dBrHXXRatio1 = BrHXXRatio - 1.0;
9658 dBrHXXRatio2 = 0.0;
9659 } else if (fstate == 2){
9660 BrHXXRatio = (myNPbase->BrHgagaRatio());
9661 dBrHXXRatio1 = BrHXXRatio - 1.0;
9662 dBrHXXRatio2 = 0.0;
9663 } else if (fstate == 3){
9664 BrHXXRatio = (myNPbase->BrHbbRatio());
9665 dBrHXXRatio1 = BrHXXRatio - 1.0;
9666 dBrHXXRatio2 = 0.0;
9667 } else if (fstate == 4){
9668 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9669 dBrHXXRatio1 = BrHXXRatio - 1.0;
9670 dBrHXXRatio2 = 0.0;
9671 } else if (fstate == 5){
9672 BrHXXRatio = (myNPbase->BrHtautauRatio());
9673 dBrHXXRatio1 = BrHXXRatio - 1.0;
9674 dBrHXXRatio2 = 0.0;
9675 } else if (fstate == 6){
9676 BrHXXRatio = (myNPbase->BrHWWRatio());
9677 dBrHXXRatio1 = BrHXXRatio - 1.0;
9678 dBrHXXRatio2 = 0.0;
9679 } else if (fstate == 7){
9680 BrHXXRatio = (myNPbase->BrHZZRatio());
9681 dBrHXXRatio1 = BrHXXRatio - 1.0;
9682 dBrHXXRatio2 = 0.0;
9683 } else {
9684 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9685 }
9686
9687 //-- Production x Decay:
9688 if ((this->getModel()).isModelLinearized()){
9689 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9690 } else if((this->getModel()).isModelNPquadratic()){
9691 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9692 } else {
9693 return weight*(muProd)*(BrHXXRatio);
9694 }
9695
9696
9697
9698
9699
9700
9701
9702}
9703
9704// -----------------------------------------------------------------------------
9705
9707: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9708{
9709 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9710 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9711
9712}
9713
9715{
9716
9717 //-- Production:
9718 double weight = 1.0; //If normalized to the SM
9720 double muProd1 = muProd -1.0;
9721 double muProd2 = 0.0;
9722
9723 //-- Decay:
9724 double BrHXXRatio = 1.0;
9725 double dBrHXXRatio1 = 0.0;
9726 double dBrHXXRatio2 = 0.0;
9727 if (fstate==0){
9728 // Use for Cross-section [pb] with no Higgs-boson decay
9729 weight = 0.175166; //Ref: CMS-HIG-21-018-PAS-v3
9730 } else if (fstate == 1){
9731 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9732 dBrHXXRatio1 = BrHXXRatio - 1.0;
9733 dBrHXXRatio2 = 0.0;
9734 } else if (fstate == 2){
9735 BrHXXRatio = (myNPbase->BrHgagaRatio());
9736 dBrHXXRatio1 = BrHXXRatio - 1.0;
9737 dBrHXXRatio2 = 0.0;
9738 } else if (fstate == 3){
9739 BrHXXRatio = (myNPbase->BrHbbRatio());
9740 dBrHXXRatio1 = BrHXXRatio - 1.0;
9741 dBrHXXRatio2 = 0.0;
9742 } else if (fstate == 4){
9743 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9744 dBrHXXRatio1 = BrHXXRatio - 1.0;
9745 dBrHXXRatio2 = 0.0;
9746 } else if (fstate == 5){
9747 BrHXXRatio = (myNPbase->BrHtautauRatio());
9748 dBrHXXRatio1 = BrHXXRatio - 1.0;
9749 dBrHXXRatio2 = 0.0;
9750 } else if (fstate == 6){
9751 BrHXXRatio = (myNPbase->BrHWWRatio());
9752 dBrHXXRatio1 = BrHXXRatio - 1.0;
9753 dBrHXXRatio2 = 0.0;
9754 } else if (fstate == 7){
9755 BrHXXRatio = (myNPbase->BrHZZRatio());
9756 dBrHXXRatio1 = BrHXXRatio - 1.0;
9757 dBrHXXRatio2 = 0.0;
9758 } else {
9759 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9760 }
9761
9762 //-- Production x Decay:
9763 if ((this->getModel()).isModelLinearized()){
9764 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9765 } else if((this->getModel()).isModelNPquadratic()){
9766 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9767 } else {
9768 return weight*(muProd)*(BrHXXRatio);
9769 }
9770
9771
9772
9773}
9774
9775// -----------------------------------------------------------------------------
9776
9778: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9779{
9780 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9781 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9782
9783}
9784
9786{
9787
9788
9789
9790 //-- Production:
9791 double weight = 1.0; //If normalized to the SM
9793 double muProd1 = muProd -1.0;
9794 double muProd2 = 0.0;
9795
9796 //-- Decay:
9797 double BrHXXRatio = 1.0;
9798 double dBrHXXRatio1 = 0.0;
9799 double dBrHXXRatio2 = 0.0;
9800 if (fstate==0){
9801 // Use for Cross-section [pb] with no Higgs-boson decay
9802 weight = 0.571956; //Ref: CMS-HIG-21-018-PAS-v3
9803 } else if (fstate == 1){
9804 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9805 dBrHXXRatio1 = BrHXXRatio - 1.0;
9806 dBrHXXRatio2 = 0.0;
9807 } else if (fstate == 2){
9808 BrHXXRatio = (myNPbase->BrHgagaRatio());
9809 dBrHXXRatio1 = BrHXXRatio - 1.0;
9810 dBrHXXRatio2 = 0.0;
9811 } else if (fstate == 3){
9812 BrHXXRatio = (myNPbase->BrHbbRatio());
9813 dBrHXXRatio1 = BrHXXRatio - 1.0;
9814 dBrHXXRatio2 = 0.0;
9815 } else if (fstate == 4){
9816 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9817 dBrHXXRatio1 = BrHXXRatio - 1.0;
9818 dBrHXXRatio2 = 0.0;
9819 } else if (fstate == 5){
9820 BrHXXRatio = (myNPbase->BrHtautauRatio());
9821 dBrHXXRatio1 = BrHXXRatio - 1.0;
9822 dBrHXXRatio2 = 0.0;
9823 } else if (fstate == 6){
9824 BrHXXRatio = (myNPbase->BrHWWRatio());
9825 dBrHXXRatio1 = BrHXXRatio - 1.0;
9826 dBrHXXRatio2 = 0.0;
9827 } else if (fstate == 7){
9828 BrHXXRatio = (myNPbase->BrHZZRatio());
9829 dBrHXXRatio1 = BrHXXRatio - 1.0;
9830 dBrHXXRatio2 = 0.0;
9831 } else {
9832 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9833 }
9834
9835 //-- Production x Decay:
9836 if ((this->getModel()).isModelLinearized()){
9837 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9838 } else if((this->getModel()).isModelNPquadratic()){
9839 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9840 } else {
9841 return weight*(muProd)*(BrHXXRatio);
9842 }
9843
9844
9845
9846
9847}
9848
9849// -----------------------------------------------------------------------------
9850
9852: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9853{
9854 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9855 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9856
9857}
9858
9860{
9861
9862
9863
9864
9865
9866 //-- Production:
9867 double weight = 1.0; //If normalized to the SM
9869 double muProd1 = muProd -1.0;
9870 double muProd2 = 0.0;
9871
9872 //-- Decay:
9873 double BrHXXRatio = 1.0;
9874 double dBrHXXRatio1 = 0.0;
9875 double dBrHXXRatio2 = 0.0;
9876 if (fstate==0){
9877 // Use for Cross-section [pb] with no Higgs-boson decay
9878 weight = 0.1647; //Ref: CMS-HIG-21-018-PAS-v3
9879 } else if (fstate == 1){
9880 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9881 dBrHXXRatio1 = BrHXXRatio - 1.0;
9882 dBrHXXRatio2 = 0.0;
9883 } else if (fstate == 2){
9884 BrHXXRatio = (myNPbase->BrHgagaRatio());
9885 dBrHXXRatio1 = BrHXXRatio - 1.0;
9886 dBrHXXRatio2 = 0.0;
9887 } else if (fstate == 3){
9888 BrHXXRatio = (myNPbase->BrHbbRatio());
9889 dBrHXXRatio1 = BrHXXRatio - 1.0;
9890 dBrHXXRatio2 = 0.0;
9891 } else if (fstate == 4){
9892 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9893 dBrHXXRatio1 = BrHXXRatio - 1.0;
9894 dBrHXXRatio2 = 0.0;
9895 } else if (fstate == 5){
9896 BrHXXRatio = (myNPbase->BrHtautauRatio());
9897 dBrHXXRatio1 = BrHXXRatio - 1.0;
9898 dBrHXXRatio2 = 0.0;
9899 } else if (fstate == 6){
9900 BrHXXRatio = (myNPbase->BrHWWRatio());
9901 dBrHXXRatio1 = BrHXXRatio - 1.0;
9902 dBrHXXRatio2 = 0.0;
9903 } else if (fstate == 7){
9904 BrHXXRatio = (myNPbase->BrHZZRatio());
9905 dBrHXXRatio1 = BrHXXRatio - 1.0;
9906 dBrHXXRatio2 = 0.0;
9907 } else {
9908 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9909 }
9910
9911 //-- Production x Decay:
9912 if ((this->getModel()).isModelLinearized()){
9913 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9914 } else if((this->getModel()).isModelNPquadratic()){
9915 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9916 } else {
9917 return weight*(muProd)*(BrHXXRatio);
9918 }
9919
9920
9921
9922
9923
9924
9925}
9926
9927
9928
9929
9930
9931
9932// -----------------------------------------------------------------------------
9933
9934
9935
9936//VM:STXS2025
9938: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9939{
9940 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9941 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9942
9943}
9944
9946{
9947
9948
9949
9950 //-- Production:
9951 double weight = 1.0; //If normalized to the SM
9952 double muProd = (
9955 )/(0.175166+0.1647);
9956 double muProd1 = muProd -1.0;
9957 double muProd2 = 0.0;
9958
9959 //-- Decay:
9960 double BrHXXRatio = 1.0;
9961 double dBrHXXRatio1 = 0.0;
9962 double dBrHXXRatio2 = 0.0;
9963 if (fstate==0){
9964 // Use for Cross-section [pb] with no Higgs-boson decay
9965 weight = 0.1647; //Ref: CMS-HIG-21-018-PAS-v3
9966 } else if (fstate == 1){
9967 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9968 dBrHXXRatio1 = BrHXXRatio - 1.0;
9969 dBrHXXRatio2 = 0.0;
9970 } else if (fstate == 2){
9971 BrHXXRatio = (myNPbase->BrHgagaRatio());
9972 dBrHXXRatio1 = BrHXXRatio - 1.0;
9973 dBrHXXRatio2 = 0.0;
9974 } else if (fstate == 3){
9975 BrHXXRatio = (myNPbase->BrHbbRatio());
9976 dBrHXXRatio1 = BrHXXRatio - 1.0;
9977 dBrHXXRatio2 = 0.0;
9978 } else if (fstate == 4){
9979 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9980 dBrHXXRatio1 = BrHXXRatio - 1.0;
9981 dBrHXXRatio2 = 0.0;
9982 } else if (fstate == 5){
9983 BrHXXRatio = (myNPbase->BrHtautauRatio());
9984 dBrHXXRatio1 = BrHXXRatio - 1.0;
9985 dBrHXXRatio2 = 0.0;
9986 } else if (fstate == 6){
9987 BrHXXRatio = (myNPbase->BrHWWRatio());
9988 dBrHXXRatio1 = BrHXXRatio - 1.0;
9989 dBrHXXRatio2 = 0.0;
9990 } else if (fstate == 7){
9991 BrHXXRatio = (myNPbase->BrHZZRatio());
9992 dBrHXXRatio1 = BrHXXRatio - 1.0;
9993 dBrHXXRatio2 = 0.0;
9994 } else {
9995 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9996 }
9997
9998 //-- Production x Decay:
9999 if ((this->getModel()).isModelLinearized()){
10000 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10001 } else if((this->getModel()).isModelNPquadratic()){
10002 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10003 } else {
10004 return weight*(muProd)*(BrHXXRatio);
10005 }
10006
10007
10008
10009}
10010
10011
10012
10013
10014
10015
10016
10017// -----------------------------------------------------------------------------
10018
10019//AG:STXS2024
10020STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10021: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10022{
10023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10024 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10025
10026}
10027
10029{
10030 //-- Production:
10031 double weight = 1.0; //If normalized to the SM
10033 double muProd1 = muProd -1.0;
10034 double muProd2 = 0.0;
10035
10036 //-- Decay:
10037 double BrHXXRatio = 1.0;
10038 double dBrHXXRatio1 = 0.0;
10039 double dBrHXXRatio2 = 0.0;
10040 if (fstate==0){
10041 // Use for Cross-section [pb] with no Higgs-boson decay
10042 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10043 } else if (fstate == 1){
10044 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10045 dBrHXXRatio1 = BrHXXRatio - 1.0;
10046 dBrHXXRatio2 = 0.0;
10047 } else if (fstate == 2){
10048 BrHXXRatio = (myNPbase->BrHgagaRatio());
10049 dBrHXXRatio1 = BrHXXRatio - 1.0;
10050 dBrHXXRatio2 = 0.0;
10051 } else if (fstate == 3){
10052 BrHXXRatio = (myNPbase->BrHbbRatio());
10053 dBrHXXRatio1 = BrHXXRatio - 1.0;
10054 dBrHXXRatio2 = 0.0;
10055 } else if (fstate == 4){
10056 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10057 dBrHXXRatio1 = BrHXXRatio - 1.0;
10058 dBrHXXRatio2 = 0.0;
10059 } else if (fstate == 5){
10060 BrHXXRatio = (myNPbase->BrHtautauRatio());
10061 dBrHXXRatio1 = BrHXXRatio - 1.0;
10062 dBrHXXRatio2 = 0.0;
10063 } else if (fstate == 6){
10064 BrHXXRatio = (myNPbase->BrHWWRatio());
10065 dBrHXXRatio1 = BrHXXRatio - 1.0;
10066 dBrHXXRatio2 = 0.0;
10067 } else if (fstate == 7){
10068 BrHXXRatio = (myNPbase->BrHZZRatio());
10069 dBrHXXRatio1 = BrHXXRatio - 1.0;
10070 dBrHXXRatio2 = 0.0;
10071 } else {
10072 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10073 }
10074
10075 //-- Production x Decay:
10076 if ((this->getModel()).isModelLinearized()){
10077 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10078 } else if((this->getModel()).isModelNPquadratic()){
10079 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10080 } else {
10081 return weight*(muProd)*(BrHXXRatio);
10082 }
10083
10084
10085}
10086
10087// -----------------------------------------------------------------------------
10088
10089//AG:STXS2024
10090STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10091: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10092{
10093 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10094 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10095
10096}
10097
10099{
10100 //-- Production:
10101 double weight = 1.0; //If normalized to the SM
10103 double muProd1 = muProd -1.0;
10104 double muProd2 = 0.0;
10105
10106 //-- Decay:
10107 double BrHXXRatio = 1.0;
10108 double dBrHXXRatio1 = 0.0;
10109 double dBrHXXRatio2 = 0.0;
10110 if (fstate==0){
10111 // Use for Cross-section [pb] with no Higgs-boson decay
10112 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10113 } else if (fstate == 1){
10114 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10115 dBrHXXRatio1 = BrHXXRatio - 1.0;
10116 dBrHXXRatio2 = 0.0;
10117 } else if (fstate == 2){
10118 BrHXXRatio = (myNPbase->BrHgagaRatio());
10119 dBrHXXRatio1 = BrHXXRatio - 1.0;
10120 dBrHXXRatio2 = 0.0;
10121 } else if (fstate == 3){
10122 BrHXXRatio = (myNPbase->BrHbbRatio());
10123 dBrHXXRatio1 = BrHXXRatio - 1.0;
10124 dBrHXXRatio2 = 0.0;
10125 } else if (fstate == 4){
10126 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10127 dBrHXXRatio1 = BrHXXRatio - 1.0;
10128 dBrHXXRatio2 = 0.0;
10129 } else if (fstate == 5){
10130 BrHXXRatio = (myNPbase->BrHtautauRatio());
10131 dBrHXXRatio1 = BrHXXRatio - 1.0;
10132 dBrHXXRatio2 = 0.0;
10133 } else if (fstate == 6){
10134 BrHXXRatio = (myNPbase->BrHWWRatio());
10135 dBrHXXRatio1 = BrHXXRatio - 1.0;
10136 dBrHXXRatio2 = 0.0;
10137 } else if (fstate == 7){
10138 BrHXXRatio = (myNPbase->BrHZZRatio());
10139 dBrHXXRatio1 = BrHXXRatio - 1.0;
10140 dBrHXXRatio2 = 0.0;
10141 } else {
10142 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10143 }
10144
10145 //-- Production x Decay:
10146 if ((this->getModel()).isModelLinearized()){
10147 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10148 } else if((this->getModel()).isModelNPquadratic()){
10149 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10150 } else {
10151 return weight*(muProd)*(BrHXXRatio);
10152 }
10153
10154
10155}
10156
10157// -----------------------------------------------------------------------------
10158
10159//AG:STXS2024
10160STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10161: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10162{
10163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10164 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10165
10166}
10167
10169{
10170 //-- Production:
10171 double weight = 1.0; //If normalized to the SM
10173 double muProd1 = muProd -1.0;
10174 double muProd2 = 0.0;
10175
10176 //-- Decay:
10177 double BrHXXRatio = 1.0;
10178 double dBrHXXRatio1 = 0.0;
10179 double dBrHXXRatio2 = 0.0;
10180 if (fstate==0){
10181 // Use for Cross-section [pb] with no Higgs-boson decay
10182 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10183 } else if (fstate == 1){
10184 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10185 dBrHXXRatio1 = BrHXXRatio - 1.0;
10186 dBrHXXRatio2 = 0.0;
10187 } else if (fstate == 2){
10188 BrHXXRatio = (myNPbase->BrHgagaRatio());
10189 dBrHXXRatio1 = BrHXXRatio - 1.0;
10190 dBrHXXRatio2 = 0.0;
10191 } else if (fstate == 3){
10192 BrHXXRatio = (myNPbase->BrHbbRatio());
10193 dBrHXXRatio1 = BrHXXRatio - 1.0;
10194 dBrHXXRatio2 = 0.0;
10195 } else if (fstate == 4){
10196 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10197 dBrHXXRatio1 = BrHXXRatio - 1.0;
10198 dBrHXXRatio2 = 0.0;
10199 } else if (fstate == 5){
10200 BrHXXRatio = (myNPbase->BrHtautauRatio());
10201 dBrHXXRatio1 = BrHXXRatio - 1.0;
10202 dBrHXXRatio2 = 0.0;
10203 } else if (fstate == 6){
10204 BrHXXRatio = (myNPbase->BrHWWRatio());
10205 dBrHXXRatio1 = BrHXXRatio - 1.0;
10206 dBrHXXRatio2 = 0.0;
10207 } else if (fstate == 7){
10208 BrHXXRatio = (myNPbase->BrHZZRatio());
10209 dBrHXXRatio1 = BrHXXRatio - 1.0;
10210 dBrHXXRatio2 = 0.0;
10211 } else {
10212 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10213 }
10214
10215 //-- Production x Decay:
10216 if ((this->getModel()).isModelLinearized()){
10217 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10218 } else if((this->getModel()).isModelNPquadratic()){
10219 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10220 } else {
10221 return weight*(muProd)*(BrHXXRatio);
10222 }
10223
10224
10225}
10226
10227// -----------------------------------------------------------------------------
10228
10229//AG:STXS2024
10230STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10231: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10232{
10233 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10234 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10235
10236}
10237
10239{
10240 //-- Production:
10241 double weight = 1.0; //If normalized to the SM
10243 double muProd1 = muProd -1.0;
10244 double muProd2 = 0.0;
10245
10246 //-- Decay:
10247 double BrHXXRatio = 1.0;
10248 double dBrHXXRatio1 = 0.0;
10249 double dBrHXXRatio2 = 0.0;
10250 if (fstate==0){
10251 // Use for Cross-section [pb] with no Higgs-boson decay
10252 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10253 } else if (fstate == 1){
10254 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10255 dBrHXXRatio1 = BrHXXRatio - 1.0;
10256 dBrHXXRatio2 = 0.0;
10257 } else if (fstate == 2){
10258 BrHXXRatio = (myNPbase->BrHgagaRatio());
10259 dBrHXXRatio1 = BrHXXRatio - 1.0;
10260 dBrHXXRatio2 = 0.0;
10261 } else if (fstate == 3){
10262 BrHXXRatio = (myNPbase->BrHbbRatio());
10263 dBrHXXRatio1 = BrHXXRatio - 1.0;
10264 dBrHXXRatio2 = 0.0;
10265 } else if (fstate == 4){
10266 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10267 dBrHXXRatio1 = BrHXXRatio - 1.0;
10268 dBrHXXRatio2 = 0.0;
10269 } else if (fstate == 5){
10270 BrHXXRatio = (myNPbase->BrHtautauRatio());
10271 dBrHXXRatio1 = BrHXXRatio - 1.0;
10272 dBrHXXRatio2 = 0.0;
10273 } else if (fstate == 6){
10274 BrHXXRatio = (myNPbase->BrHWWRatio());
10275 dBrHXXRatio1 = BrHXXRatio - 1.0;
10276 dBrHXXRatio2 = 0.0;
10277 } else if (fstate == 7){
10278 BrHXXRatio = (myNPbase->BrHZZRatio());
10279 dBrHXXRatio1 = BrHXXRatio - 1.0;
10280 dBrHXXRatio2 = 0.0;
10281 } else {
10282 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10283 }
10284
10285 //-- Production x Decay:
10286 if ((this->getModel()).isModelLinearized()){
10287 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10288 } else if((this->getModel()).isModelNPquadratic()){
10289 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10290 } else {
10291 return weight*(muProd)*(BrHXXRatio);
10292 }
10293
10294}
10295
10296// -----------------------------------------------------------------------------
10297
10298//AG:STXS2024
10299STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10300: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10301{
10302 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10303 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10304
10305}
10306
10308{
10309 //-- Production:
10310 double weight = 1.0; //If normalized to the SM
10311 //Since adding bins, include partial weigths of SM_predictions
10312 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10313 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
10315 ) / (0.22408+0.21578);
10316 double muProd1 = muProd - 1.0;
10317 double muProd2 = 0.0;
10318
10319 //-- Decay:
10320 double BrHXXRatio = 1.0;
10321 double dBrHXXRatio1 = 0.0;
10322 double dBrHXXRatio2 = 0.0;
10323 if (fstate==0){
10324 // Use for Cross-section [pb] with no Higgs-boson decay
10325 weight = (0.22408+0.21578) ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10326 } else if (fstate == 1){
10327 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10328 dBrHXXRatio1 = BrHXXRatio - 1.0;
10329 dBrHXXRatio2 = 0.0;
10330 } else if (fstate == 2){
10331 BrHXXRatio = (myNPbase->BrHgagaRatio());
10332 dBrHXXRatio1 = BrHXXRatio - 1.0;
10333 dBrHXXRatio2 = 0.0;
10334 } else if (fstate == 3){
10335 BrHXXRatio = (myNPbase->BrHbbRatio());
10336 dBrHXXRatio1 = BrHXXRatio - 1.0;
10337 dBrHXXRatio2 = 0.0;
10338 } else if (fstate == 4){
10339 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10340 dBrHXXRatio1 = BrHXXRatio - 1.0;
10341 dBrHXXRatio2 = 0.0;
10342 } else if (fstate == 5){
10343 BrHXXRatio = (myNPbase->BrHtautauRatio());
10344 dBrHXXRatio1 = BrHXXRatio - 1.0;
10345 dBrHXXRatio2 = 0.0;
10346 } else if (fstate == 6){
10347 BrHXXRatio = (myNPbase->BrHWWRatio());
10348 dBrHXXRatio1 = BrHXXRatio - 1.0;
10349 dBrHXXRatio2 = 0.0;
10350 } else if (fstate == 7){
10351 BrHXXRatio = (myNPbase->BrHZZRatio());
10352 dBrHXXRatio1 = BrHXXRatio - 1.0;
10353 dBrHXXRatio2 = 0.0;
10354 } else {
10355 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10356 }
10357
10358 //-- Production x Decay:
10359 if ((this->getModel()).isModelLinearized()){
10360 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10361 } else if((this->getModel()).isModelNPquadratic()){
10362 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10363 } else {
10364 return weight*(muProd)*(BrHXXRatio);
10365 }
10366
10367
10368}
10369
10370
10371
10372// -----------------------------------------------------------------------------
10373
10374//VM:STXS2025
10375STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10376: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10377{
10378 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10379 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10380
10381}
10382
10384{
10385 //-- Production:
10386 double weight = 1.0; //If normalized to the SM
10387 //Since adding bins, include partial weigths of SM_predictions
10388 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10389 double muProd = (0.25614*(myNPbase->STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(sqrt_s))
10392 )/(0.25614+0.22408+0.21578);
10393 double muProd1 = (muProd-1.0);
10394 double muProd2 = 0.0;
10395
10396 //-- Decay:
10397 double BrHXXRatio = 1.0;
10398 double dBrHXXRatio1 = 0.0;
10399 double dBrHXXRatio2 = 0.0;
10400 if (fstate==0){
10401 // Use for Cross-section [pb] with no Higgs-boson decay
10402 weight = (0.25614+0.22408+0.21578); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10403 } else if (fstate == 1){
10404 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10405 dBrHXXRatio1 = BrHXXRatio - 1.0;
10406 dBrHXXRatio2 = 0.0;
10407 } else if (fstate == 2){
10408 BrHXXRatio = (myNPbase->BrHgagaRatio());
10409 dBrHXXRatio1 = BrHXXRatio - 1.0;
10410 dBrHXXRatio2 = 0.0;
10411 } else if (fstate == 3){
10412 BrHXXRatio = (myNPbase->BrHbbRatio());
10413 dBrHXXRatio1 = BrHXXRatio - 1.0;
10414 dBrHXXRatio2 = 0.0;
10415 } else if (fstate == 4){
10416 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10417 dBrHXXRatio1 = BrHXXRatio - 1.0;
10418 dBrHXXRatio2 = 0.0;
10419 } else if (fstate == 5){
10420 BrHXXRatio = (myNPbase->BrHtautauRatio());
10421 dBrHXXRatio1 = BrHXXRatio - 1.0;
10422 dBrHXXRatio2 = 0.0;
10423 } else if (fstate == 6){
10424 BrHXXRatio = (myNPbase->BrHWWRatio());
10425 dBrHXXRatio1 = BrHXXRatio - 1.0;
10426 dBrHXXRatio2 = 0.0;
10427 } else if (fstate == 7){
10428 BrHXXRatio = (myNPbase->BrHZZRatio());
10429 dBrHXXRatio1 = BrHXXRatio - 1.0;
10430 dBrHXXRatio2 = 0.0;
10431 } else {
10432 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10433 }
10434
10435 //-- Production x Decay:
10436 if ((this->getModel()).isModelLinearized()){
10437 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10438 } else if((this->getModel()).isModelNPquadratic()){
10439 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10440 } else {
10441 return weight*(muProd)*(BrHXXRatio);
10442 }
10443
10444
10445}
10446
10447
10448
10449
10450// -----------------------------------------------------------------------------
10451
10452//AG:STXS2024
10453STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10454: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10455{
10456 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10457 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
10458
10459}
10460
10462{
10463 //-- Production:
10464 double weight = 1.0; //If normalized to the SM
10466 double muProd1 = muProd -1.0;
10467 double muProd2 = 0.0;
10468
10469 //-- Decay:
10470 double BrHXXRatio = 1.0;
10471 double dBrHXXRatio1 = 0.0;
10472 double dBrHXXRatio2 = 0.0;
10473 if (fstate==0){
10474 // Use for Cross-section [pb] with no Higgs-boson decay
10475 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10476 } else if (fstate == 1){
10477 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10478 dBrHXXRatio1 = BrHXXRatio - 1.0;
10479 dBrHXXRatio2 = 0.0;
10480 } else if (fstate == 2){
10481 BrHXXRatio = (myNPbase->BrHgagaRatio());
10482 dBrHXXRatio1 = BrHXXRatio - 1.0;
10483 dBrHXXRatio2 = 0.0;
10484 } else if (fstate == 3){
10485 BrHXXRatio = (myNPbase->BrHbbRatio());
10486 dBrHXXRatio1 = BrHXXRatio - 1.0;
10487 dBrHXXRatio2 = 0.0;
10488 } else if (fstate == 4){
10489 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10490 dBrHXXRatio1 = BrHXXRatio - 1.0;
10491 dBrHXXRatio2 = 0.0;
10492 } else {
10493 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
10494 }
10495
10496 //-- Production x Decay:
10497 if ((this->getModel()).isModelLinearized()){
10498 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10499 } else if((this->getModel()).isModelNPquadratic()){
10500 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10501 } else {
10502 return weight*(muProd)*(BrHXXRatio);
10503 }
10504
10505
10506}
10507
10508// -----------------------------------------------------------------------------
10509
10510//AG:STXS2024
10511STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10512: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10513{
10514 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10515 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
10516
10517}
10518
10520{
10521 //-- Production:
10522 double weight = 1.0; //If normalized to the SM
10524 double muProd1 = muProd -1.0;
10525 double muProd2 = 0.0;
10526
10527 //-- Decay:
10528 double BrHXXRatio = 1.0;
10529 double dBrHXXRatio1 = 0.0;
10530 double dBrHXXRatio2 = 0.0;
10531 if (fstate==0){
10532 // Use for Cross-section [pb] with no Higgs-boson decay
10533 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10534 } else if (fstate == 1){
10535 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10536 dBrHXXRatio1 = BrHXXRatio - 1.0;
10537 dBrHXXRatio2 = 0.0;
10538 } else if (fstate == 2){
10539 BrHXXRatio = (myNPbase->BrHgagaRatio());
10540 dBrHXXRatio1 = BrHXXRatio - 1.0;
10541 dBrHXXRatio2 = 0.0;
10542 } else if (fstate == 3){
10543 BrHXXRatio = (myNPbase->BrHbbRatio());
10544 dBrHXXRatio1 = BrHXXRatio - 1.0;
10545 dBrHXXRatio2 = 0.0;
10546 } else if (fstate == 4){
10547 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10548 dBrHXXRatio1 = BrHXXRatio - 1.0;
10549 dBrHXXRatio2 = 0.0;
10550 } else {
10551 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
10552 }
10553
10554 //-- Production x Decay:
10555 if ((this->getModel()).isModelLinearized()){
10556 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10557 } else if((this->getModel()).isModelNPquadratic()){
10558 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10559 } else {
10560 return weight*(muProd)*(BrHXXRatio);
10561 }
10562
10563
10564}
10565
10566// -----------------------------------------------------------------------------
10567
10568STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10569: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10570{
10571 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10572 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
10573
10574}
10575
10577{
10578 //-- Production:
10579 double weight = 1.0; //If normalized to the SM
10580 //Since adding bins, include partial weigths of SM_predictions
10581 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10582
10583 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
10589 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
10590
10591 double muProd1 = muProd - 1.;
10592 double muProd2 = 0.0;
10593
10594 //-- Decay:
10595 double BrHXXRatio = 1.0;
10596 double dBrHXXRatio1 = 0.0;
10597 double dBrHXXRatio2 = 0.0;
10598 if (fstate==0){
10599 // Use for Cross-section [pb] with no Higgs-boson decay
10600 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
10601 } else if (fstate == 1){
10602 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10603 dBrHXXRatio1 = BrHXXRatio - 1.0;
10604 dBrHXXRatio2 = 0.0;
10605 } else if (fstate == 2){
10606 BrHXXRatio = (myNPbase->BrHgagaRatio());
10607 dBrHXXRatio1 = BrHXXRatio - 1.0;
10608 dBrHXXRatio2 = 0.0;
10609 } else if (fstate == 3){
10610 BrHXXRatio = (myNPbase->BrHbbRatio());
10611 dBrHXXRatio1 = BrHXXRatio - 1.0;
10612 dBrHXXRatio2 = 0.0;
10613 } else if (fstate == 4){
10614 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10615 dBrHXXRatio1 = BrHXXRatio - 1.0;
10616 dBrHXXRatio2 = 0.0;
10617 } else if (fstate == 5){
10618 BrHXXRatio = (myNPbase->BrHtautauRatio());
10619 dBrHXXRatio1 = BrHXXRatio - 1.0;
10620 dBrHXXRatio2 = 0.0;
10621 } else {
10622 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10623 }
10624
10625
10626
10627
10628 //-- Production x Decay:
10629 if ((this->getModel()).isModelLinearized()){
10630// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
10631 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10632 } else if((this->getModel()).isModelNPquadratic()){
10633// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
10634 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10635 } else {
10636// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
10637 return weight*(muProd)*(BrHXXRatio);
10638 }
10639
10640}
10641
10642// -----------------------------------------------------------------------------
10643
10644STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10645: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10646{
10647 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10648 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
10649
10650}
10651
10653{
10654 //-- Production:
10655 double weight = 1.0; //If normalized to the SM
10656 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
10657 double muProd1 = muProd -1.0;
10658 double muProd2 = 0.0;
10659
10660 //-- Decay:
10661 double BrHXXRatio = 1.0;
10662 double dBrHXXRatio1 = 0.0;
10663 double dBrHXXRatio2 = 0.0;
10664 if (fstate==0){
10665 // Use for Cross-section [pb] with no Higgs-boson decay
10666 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10667 } else if (fstate == 1){
10668 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10669 dBrHXXRatio1 = BrHXXRatio - 1.0;
10670 dBrHXXRatio2 = 0.0;
10671 } else if (fstate == 2){
10672 BrHXXRatio = (myNPbase->BrHgagaRatio());
10673 dBrHXXRatio1 = BrHXXRatio - 1.0;
10674 dBrHXXRatio2 = 0.0;
10675 } else if (fstate == 3){
10676 BrHXXRatio = (myNPbase->BrHbbRatio());
10677 dBrHXXRatio1 = BrHXXRatio - 1.0;
10678 dBrHXXRatio2 = 0.0;
10679 } else if (fstate == 4){
10680 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10681 dBrHXXRatio1 = BrHXXRatio - 1.0;
10682 dBrHXXRatio2 = 0.0;
10683 } else if (fstate == 5){
10684 BrHXXRatio = (myNPbase->BrHtautauRatio());
10685 dBrHXXRatio1 = BrHXXRatio - 1.0;
10686 dBrHXXRatio2 = 0.0;
10687 } else {
10688 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10689 }
10690
10691 //-- Production x Decay:
10692 if ((this->getModel()).isModelLinearized()){
10693 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10694 } else if((this->getModel()).isModelNPquadratic()){
10695 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10696 } else {
10697 return weight*(muProd)*(BrHXXRatio);
10698 }
10699
10700}
10701
10702// -----------------------------------------------------------------------------
10703
10704STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10705: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10706{
10707 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10708 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
10709
10710}
10711
10713{
10714 //-- Production:
10715 double weight = 1.0; //If normalized to the SM
10716 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
10717 double muProd1 = muProd -1.0;
10718 double muProd2 = 0.0;
10719
10720 //-- Decay:
10721 double BrHXXRatio = 1.0;
10722 double dBrHXXRatio1 = 0.0;
10723 double dBrHXXRatio2 = 0.0;
10724 if (fstate==0){
10725 // Use for Cross-section [pb] with no Higgs-boson decay
10726 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10727 } else if (fstate == 1){
10728 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10729 dBrHXXRatio1 = BrHXXRatio - 1.0;
10730 dBrHXXRatio2 = 0.0;
10731 } else if (fstate == 2){
10732 BrHXXRatio = (myNPbase->BrHgagaRatio());
10733 dBrHXXRatio1 = BrHXXRatio - 1.0;
10734 dBrHXXRatio2 = 0.0;
10735 } else if (fstate == 3){
10736 BrHXXRatio = (myNPbase->BrHbbRatio());
10737 dBrHXXRatio1 = BrHXXRatio - 1.0;
10738 dBrHXXRatio2 = 0.0;
10739 } else if (fstate == 4){
10740 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10741 dBrHXXRatio1 = BrHXXRatio - 1.0;
10742 dBrHXXRatio2 = 0.0;
10743 } else if (fstate == 5){
10744 BrHXXRatio = (myNPbase->BrHtautauRatio());
10745 dBrHXXRatio1 = BrHXXRatio - 1.0;
10746 dBrHXXRatio2 = 0.0;
10747 } else {
10748 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10749 }
10750
10751 //-- Production x Decay:
10752 if ((this->getModel()).isModelLinearized()){
10753 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10754 } else if((this->getModel()).isModelNPquadratic()){
10755 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10756 } else {
10757 return weight*(muProd)*(BrHXXRatio);
10758 }
10759
10760}
10761
10762// -----------------------------------------------------------------------------
10763
10764//AG:STXS2024
10765STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10766: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10767{
10768 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10769 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10770
10771}
10772
10774{
10775 //-- Production:
10776 double weight = 1.0; //If normalized to the SM
10778 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10779 double muProd2 = 0.0;
10780
10781 //-- Decay:
10782 double BrHXXRatio = 1.0;
10783 double dBrHXXRatio1 = 0.0;
10784 double dBrHXXRatio2 = 0.0;
10785 if (fstate==0){
10786 // Use for Cross-section [pb] with no Higgs-boson decay
10787 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10788 } else if (fstate == 1){
10789 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10790 dBrHXXRatio1 = BrHXXRatio - 1.0;
10791 dBrHXXRatio2 = 0.0;
10792 } else if (fstate == 2){
10793 BrHXXRatio = (myNPbase->BrHgagaRatio());
10794 dBrHXXRatio1 = BrHXXRatio - 1.0;
10795 dBrHXXRatio2 = 0.0;
10796 } else if (fstate == 3){
10797 BrHXXRatio = (myNPbase->BrHbbRatio());
10798 dBrHXXRatio1 = BrHXXRatio - 1.0;
10799 dBrHXXRatio2 = 0.0;
10800 } else if (fstate == 4){
10801 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10802 dBrHXXRatio1 = BrHXXRatio - 1.0;
10803 dBrHXXRatio2 = 0.0;
10804 } else if (fstate == 5){
10805 BrHXXRatio = (myNPbase->BrHtautauRatio());
10806 dBrHXXRatio1 = BrHXXRatio - 1.0;
10807 dBrHXXRatio2 = 0.0;
10808 } else {
10809 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10810 }
10811
10812 //-- Production x Decay:
10813 if ((this->getModel()).isModelLinearized()){
10814 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10815 } else if((this->getModel()).isModelNPquadratic()){
10816 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10817 } else {
10818 return weight*(muProd)*(BrHXXRatio);
10819 }
10820
10821
10822}
10823
10824// -----------------------------------------------------------------------------
10825
10826
10827
10828
10829
10830
10831STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10832: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10833{
10834 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10835 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10836
10837}
10838
10840{
10841 double BrHXXRatio = 1.0;
10842 if (fstate == 1){
10843 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10844 } else if (fstate == 2){
10845 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10846 } else if (fstate == 3){
10847 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10848 } else if (fstate == 4){
10849 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10850 } else {
10851 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10852 }
10853
10854 if ((this->getModel()).isModelLinearized()) {
10855 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10856 } else {
10857 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10858 }
10859}
10860
10861// -----------------------------------------------------------------------------
10862
10863STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10864: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10865{
10866 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10867 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10868
10869}
10870
10872{
10873
10874 //-- Production:
10875 double weight = 1.0; //If normalized to the SM
10876 //Since adding bins, include partial weigths of SM_predictions
10877 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10878 double muProd = (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s));
10879 double muProd1 = (muProd -1.);
10880 double muProd2 = 0.0;
10881
10882 //-- Decay:
10883 double BrHXXRatio = 1.0;
10884 double dBrHXXRatio1 = 0.0;
10885 double dBrHXXRatio2 = 0.0;
10886 if (fstate==0){
10887 // Use for Cross-section [pb] with no Higgs-boson decay
10888 weight = (0.01127+0.00339) ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10889 } else if (fstate == 1){
10890 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10891 dBrHXXRatio1 = BrHXXRatio - 1.0;
10892 dBrHXXRatio2 = 0.0;
10893 } else if (fstate == 2){
10894 BrHXXRatio = (myNPbase->BrHgagaRatio());
10895 dBrHXXRatio1 = BrHXXRatio - 1.0;
10896 dBrHXXRatio2 = 0.0;
10897 } else if (fstate == 3){
10898 BrHXXRatio = (myNPbase->BrHbbRatio());
10899 dBrHXXRatio1 = BrHXXRatio - 1.0;
10900 dBrHXXRatio2 = 0.0;
10901 } else if (fstate == 4){
10902 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10903 dBrHXXRatio1 = BrHXXRatio - 1.0;
10904 dBrHXXRatio2 = 0.0;
10905 } else if (fstate == 5){
10906 BrHXXRatio = (myNPbase->BrHtautauRatio());
10907 dBrHXXRatio1 = BrHXXRatio - 1.0;
10908 dBrHXXRatio2 = 0.0;
10909 } else if (fstate == 6){
10910 BrHXXRatio = (myNPbase->BrHWWRatio());
10911 dBrHXXRatio1 = BrHXXRatio - 1.0;
10912 dBrHXXRatio2 = 0.0;
10913 } else if (fstate == 7){
10914 BrHXXRatio = (myNPbase->BrHZZRatio());
10915 dBrHXXRatio1 = BrHXXRatio - 1.0;
10916 dBrHXXRatio2 = 0.0;
10917 } else {
10918 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10919 }
10920
10921 //-- Production x Decay:
10922 if ((this->getModel()).isModelLinearized()){
10923 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10924 } else if((this->getModel()).isModelNPquadratic()){
10925 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10926 } else {
10927 return weight*(muProd)*(BrHXXRatio);
10928 }
10929
10930
10931}
10932
10933// -----------------------------------------------------------------------------
10934
10935//AG:STXS2024
10936STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10937: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10938{
10939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10940 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10941
10942}
10943
10945{
10946 //-- Production:
10947 double weight = 1.0; //If normalized to the SM
10948 //Since adding bins, include partial weigths of SM_predictions
10949 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10950 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10951 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10952 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10953 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10954 double muProd2 = 0.0;
10955
10956 //-- Decay:
10957 double BrHXXRatio = 1.0;
10958 double dBrHXXRatio1 = 0.0;
10959 double dBrHXXRatio2 = 0.0;
10960 if (fstate==0){
10961 // Use for Cross-section [pb] with no Higgs-boson decay
10962 weight = (0.21509+0.13440) ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10963 } else if (fstate == 1){
10964 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10965 dBrHXXRatio1 = BrHXXRatio - 1.0;
10966 dBrHXXRatio2 = 0.0;
10967 } else if (fstate == 2){
10968 BrHXXRatio = (myNPbase->BrHgagaRatio());
10969 dBrHXXRatio1 = BrHXXRatio - 1.0;
10970 dBrHXXRatio2 = 0.0;
10971 } else if (fstate == 3){
10972 BrHXXRatio = (myNPbase->BrHbbRatio());
10973 dBrHXXRatio1 = BrHXXRatio - 1.0;
10974 dBrHXXRatio2 = 0.0;
10975 } else if (fstate == 4){
10976 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10977 dBrHXXRatio1 = BrHXXRatio - 1.0;
10978 dBrHXXRatio2 = 0.0;
10979 } else if (fstate == 5){
10980 BrHXXRatio = (myNPbase->BrHtautauRatio());
10981 dBrHXXRatio1 = BrHXXRatio - 1.0;
10982 dBrHXXRatio2 = 0.0;
10983 } else if (fstate == 6){
10984 BrHXXRatio = (myNPbase->BrHWWRatio());
10985 dBrHXXRatio1 = BrHXXRatio - 1.0;
10986 dBrHXXRatio2 = 0.0;
10987 } else if (fstate == 7){
10988 BrHXXRatio = (myNPbase->BrHZZRatio());
10989 dBrHXXRatio1 = BrHXXRatio - 1.0;
10990 dBrHXXRatio2 = 0.0;
10991 } else {
10992 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10993 }
10994
10995 //-- Production x Decay:
10996 if ((this->getModel()).isModelLinearized()){
10997 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10998 } else if((this->getModel()).isModelNPquadratic()){
10999 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11000 } else {
11001 return weight*(muProd)*(BrHXXRatio);
11002 }
11003
11004
11005}
11006
11007// -----------------------------------------------------------------------------
11008
11009//AG:STXS2024
11010STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11011: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11012{
11013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11014 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
11015
11016}
11017
11019{
11020 //-- Production:
11021 double weight = 1.0; //If normalized to the SM
11022 //Since adding bins, include partial weigths of SM_predictions
11023 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11024 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
11026 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
11027 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
11028 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
11029 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
11030 double muProd2 = 0.0;
11031
11032 //-- Decay:
11033 double BrHXXRatio = 1.0;
11034 double dBrHXXRatio1 = 0.0;
11035 double dBrHXXRatio2 = 0.0;
11036 if (fstate==0){
11037 // Use for Cross-section [pb] with no Higgs-boson decay
11038 weight = (0.04117+0.01004+0.00214) ;
11039 } else if (fstate == 1){
11040 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11041 dBrHXXRatio1 = BrHXXRatio - 1.0;
11042 dBrHXXRatio2 = 0.0;
11043 } else if (fstate == 2){
11044 BrHXXRatio = (myNPbase->BrHgagaRatio());
11045 dBrHXXRatio1 = BrHXXRatio - 1.0;
11046 dBrHXXRatio2 = 0.0;
11047 } else if (fstate == 3){
11048 BrHXXRatio = (myNPbase->BrHbbRatio());
11049 dBrHXXRatio1 = BrHXXRatio - 1.0;
11050 dBrHXXRatio2 = 0.0;
11051 } else if (fstate == 4){
11052 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11053 dBrHXXRatio1 = BrHXXRatio - 1.0;
11054 dBrHXXRatio2 = 0.0;
11055 } else if (fstate == 5){
11056 BrHXXRatio = (myNPbase->BrHtautauRatio());
11057 dBrHXXRatio1 = BrHXXRatio - 1.0;
11058 dBrHXXRatio2 = 0.0;
11059 } else if (fstate == 6){
11060 BrHXXRatio = (myNPbase->BrHWWRatio());
11061 dBrHXXRatio1 = BrHXXRatio - 1.0;
11062 dBrHXXRatio2 = 0.0;
11063 } else if (fstate == 7){
11064 BrHXXRatio = (myNPbase->BrHZZRatio());
11065 dBrHXXRatio1 = BrHXXRatio - 1.0;
11066 dBrHXXRatio2 = 0.0;
11067 } else {
11068 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
11069 }
11070
11071 //-- Production x Decay:
11072 if ((this->getModel()).isModelLinearized()){
11073 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11074 } else if((this->getModel()).isModelNPquadratic()){
11075 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11076 } else {
11077 return weight*(muProd)*(BrHXXRatio);
11078 }
11079
11080
11081}
11082
11083// -----------------------------------------------------------------------------
11084
11085//AG:STXS2024
11086STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11087: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11088{
11089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11090 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
11091
11092}
11093
11095{
11096 //-- Production:
11097 double weight = 1.0; //If normalized to the SM
11098 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
11099 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
11100 double muProd2 = 0.0;
11101
11102 //-- Decay:
11103 double BrHXXRatio = 1.0;
11104 double dBrHXXRatio1 = 0.0;
11105 double dBrHXXRatio2 = 0.0;
11106 if (fstate==0){
11107 // Use for Cross-section [pb] with no Higgs-boson decay
11108 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11109 } else if (fstate == 1){
11110 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11111 dBrHXXRatio1 = BrHXXRatio - 1.0;
11112 dBrHXXRatio2 = 0.0;
11113 } else if (fstate == 2){
11114 BrHXXRatio = (myNPbase->BrHgagaRatio());
11115 dBrHXXRatio1 = BrHXXRatio - 1.0;
11116 dBrHXXRatio2 = 0.0;
11117 } else if (fstate == 3){
11118 BrHXXRatio = (myNPbase->BrHbbRatio());
11119 dBrHXXRatio1 = BrHXXRatio - 1.0;
11120 dBrHXXRatio2 = 0.0;
11121 } else if (fstate == 4){
11122 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11123 dBrHXXRatio1 = BrHXXRatio - 1.0;
11124 dBrHXXRatio2 = 0.0;
11125 } else {
11126 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
11127 }
11128
11129 //-- Production x Decay:
11130 if ((this->getModel()).isModelLinearized()){
11131 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11132 } else if((this->getModel()).isModelNPquadratic()){
11133 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11134 } else {
11135 return weight*(muProd)*(BrHXXRatio);
11136 }
11137
11138
11139}
11140
11141// -----------------------------------------------------------------------------
11142
11143//AG:STXS2024
11144STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11145: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11146{
11147 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11148 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
11149
11150}
11151
11153{
11154 //-- Production:
11155 double weight = 1.0; //If normalized to the SM
11156 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
11157 double muProd1 = muProd-1.0 ;
11158 double muProd2 = 0.0;
11159
11160 //-- Decay:
11161 double BrHXXRatio = 1.0;
11162 double dBrHXXRatio1 = 0.0;
11163 double dBrHXXRatio2 = 0.0;
11164 if (fstate==0){
11165 // Use for Cross-section [pb] with no Higgs-boson decay
11166 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11167 } else if (fstate == 1){
11168 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11169 dBrHXXRatio1 = BrHXXRatio - 1.0;
11170 dBrHXXRatio2 = 0.0;
11171 } else if (fstate == 2){
11172 BrHXXRatio = (myNPbase->BrHgagaRatio());
11173 dBrHXXRatio1 = BrHXXRatio - 1.0;
11174 dBrHXXRatio2 = 0.0;
11175 } else if (fstate == 3){
11176 BrHXXRatio = (myNPbase->BrHbbRatio());
11177 dBrHXXRatio1 = BrHXXRatio - 1.0;
11178 dBrHXXRatio2 = 0.0;
11179 } else if (fstate == 4){
11180 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11181 dBrHXXRatio1 = BrHXXRatio - 1.0;
11182 dBrHXXRatio2 = 0.0;
11183 } else {
11184 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
11185 }
11186
11187 //-- Production x Decay:
11188 if ((this->getModel()).isModelLinearized()){
11189 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11190 } else if((this->getModel()).isModelNPquadratic()){
11191 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11192 } else {
11193 return weight*(muProd)*(BrHXXRatio);
11194 }
11195
11196
11197}
11198
11199
11200// -----------------------------------------------------------------------------
11201
11202STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11203: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11204{
11205 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11206 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
11207
11208}
11209
11211{
11212 double BrHXXRatio = 1.0;
11213 if (fstate == 1){
11214 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11215 } else if (fstate == 2){
11216 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
11217 } else if (fstate == 3){
11218 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
11219 } else if (fstate == 4){
11220 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11221 } else {
11222 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
11223 }
11224
11225 if ((this->getModel()).isModelLinearized()) {
11226 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
11227 } else {
11228 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
11229 }
11230}
11231
11232// -----------------------------------------------------------------------------
11233
11234//AG:STXS2024
11235STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11236: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11237{
11238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11239 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
11240
11241}
11242
11244{
11245 //-- Production:
11246 double weight = 1.0; //If normalized to the SM
11247 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
11248 double muProd1 = muProd -1.0;
11249 double muProd2 = 0.0;
11250
11251 //-- Decay:
11252 double BrHXXRatio = 1.0;
11253 double dBrHXXRatio1 = 0.0;
11254 double dBrHXXRatio2 = 0.0;
11255 if (fstate==0){
11256 // Use for Cross-section [pb] with no Higgs-boson decay
11257 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11258 } else if (fstate == 1){
11259 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11260 dBrHXXRatio1 = BrHXXRatio - 1.0;
11261 dBrHXXRatio2 = 0.0;
11262 } else if (fstate == 2){
11263 BrHXXRatio = (myNPbase->BrHgagaRatio());
11264 dBrHXXRatio1 = BrHXXRatio - 1.0;
11265 dBrHXXRatio2 = 0.0;
11266 } else if (fstate == 3){
11267 BrHXXRatio = (myNPbase->BrHbbRatio());
11268 dBrHXXRatio1 = BrHXXRatio - 1.0;
11269 dBrHXXRatio2 = 0.0;
11270 } else if (fstate == 4){
11271 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11272 dBrHXXRatio1 = BrHXXRatio - 1.0;
11273 dBrHXXRatio2 = 0.0;
11274 } else {
11275 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
11276 }
11277
11278 //-- Production x Decay:
11279 if ((this->getModel()).isModelLinearized()){
11280 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11281 } else if((this->getModel()).isModelNPquadratic()){
11282 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11283 } else {
11284 return weight*(muProd)*(BrHXXRatio);
11285 }
11286
11287
11288}
11289
11290// -----------------------------------------------------------------------------
11291
11292//AG:STXS2024
11293STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11294: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11295{
11296 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11297 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
11298
11299}
11300
11302{
11303 //-- Production:
11304 double weight = 1.0; //If normalized to the SM
11306 double muProd1 = muProd -1.0;
11307 double muProd2 = 0.0;
11308
11309 //-- Decay:
11310 double BrHXXRatio = 1.0;
11311 double dBrHXXRatio1 = 0.0;
11312 double dBrHXXRatio2 = 0.0;
11313 if (fstate==0){
11314 // Use for Cross-section [pb] with no Higgs-boson decay
11315 weight = 0.0147 ; //Ref: CMS-21-018-PAS-v3
11316 } else if (fstate == 1){
11317 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11318 dBrHXXRatio1 = BrHXXRatio - 1.0;
11319 dBrHXXRatio2 = 0.0;
11320 } else if (fstate == 2){
11321 BrHXXRatio = (myNPbase->BrHgagaRatio());
11322 dBrHXXRatio1 = BrHXXRatio - 1.0;
11323 dBrHXXRatio2 = 0.0;
11324 } else if (fstate == 3){
11325 BrHXXRatio = (myNPbase->BrHbbRatio());
11326 dBrHXXRatio1 = BrHXXRatio - 1.0;
11327 dBrHXXRatio2 = 0.0;
11328 } else if (fstate == 4){
11329 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11330 dBrHXXRatio1 = BrHXXRatio - 1.0;
11331 dBrHXXRatio2 = 0.0;
11332 } else {
11333 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
11334 }
11335
11336 //-- Production x Decay:
11337 if ((this->getModel()).isModelLinearized()){
11338 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11339 } else if((this->getModel()).isModelNPquadratic()){
11340 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11341 } else {
11342 return weight*(muProd)*(BrHXXRatio);
11343 }
11344
11345}
11346
11347// -----------------------------------------------------------------------------
11348
11349STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11350: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11351{
11352 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11353 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
11354
11355}
11356
11358{
11359
11360 //-- Production:
11361 double weight = 1.0; //If normalized to the SM
11363 double muProd1 = muProd -1.0;
11364 double muProd2 = 0.0;
11365
11366 //-- Decay:
11367 double BrHXXRatio = 1.0;
11368 double dBrHXXRatio1 = 0.0;
11369 double dBrHXXRatio2 = 0.0;
11370 if (fstate==0){
11371 // Use for Cross-section [pb] with no Higgs-boson decay
11372 weight = (0.0168) ; //Ref: CMS-21-018-PAS-v3
11373 } else if (fstate == 1){
11374 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11375 dBrHXXRatio1 = BrHXXRatio - 1.0;
11376 dBrHXXRatio2 = 0.0;
11377 } else if (fstate == 2){
11378 BrHXXRatio = (myNPbase->BrHgagaRatio());
11379 dBrHXXRatio1 = BrHXXRatio - 1.0;
11380 dBrHXXRatio2 = 0.0;
11381 } else if (fstate == 3){
11382 BrHXXRatio = (myNPbase->BrHbbRatio());
11383 dBrHXXRatio1 = BrHXXRatio - 1.0;
11384 dBrHXXRatio2 = 0.0;
11385 } else if (fstate == 4){
11386 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11387 dBrHXXRatio1 = BrHXXRatio - 1.0;
11388 dBrHXXRatio2 = 0.0;
11389 } else {
11390 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
11391 }
11392
11393 //-- Production x Decay:
11394 if ((this->getModel()).isModelLinearized()){
11395 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11396 } else if((this->getModel()).isModelNPquadratic()){
11397 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11398 } else {
11399 return weight*(muProd)*(BrHXXRatio);
11400 }
11401
11402
11403
11404
11405
11406}
11407
11408// -----------------------------------------------------------------------------
11409
11410STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11411: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11412{
11413 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11414 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
11415
11416}
11417
11419{
11420 double BrHXXRatio = 1.0;
11421 if (fstate == 1){
11422 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11423 } else if (fstate == 2){
11424 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
11425 } else if (fstate == 3){
11426 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
11427 } else if (fstate == 4){
11428 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11429 } else {
11430 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
11431 }
11432
11433 if ((this->getModel()).isModelLinearized()) {
11434 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
11435 } else {
11436 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
11437 }
11438}
11439
11440
11441// -----------------------------------------------------------------------------
11442
11443//AG:STXS2024
11444STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11445: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11446{
11447 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11448 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
11449
11450}
11451
11453{
11454 //-- Production:
11455 double weight = 1.0; //If normalized to the SM
11456 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
11457 double muProd1 = muProd -1.0;
11458 double muProd2 = 0.0;
11459
11460 //-- Decay:
11461 double BrHXXRatio = 1.0;
11462 double dBrHXXRatio1 = 0.0;
11463 double dBrHXXRatio2 = 0.0;
11464 if (fstate==0){
11465 // Use for Cross-section [pb] with no Higgs-boson decay
11466 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11467 } else if (fstate == 1){
11468 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11469 dBrHXXRatio1 = BrHXXRatio - 1.0;
11470 dBrHXXRatio2 = 0.0;
11471 } else if (fstate == 2){
11472 BrHXXRatio = (myNPbase->BrHgagaRatio());
11473 dBrHXXRatio1 = BrHXXRatio - 1.0;
11474 dBrHXXRatio2 = 0.0;
11475 } else if (fstate == 3){
11476 BrHXXRatio = (myNPbase->BrHbbRatio());
11477 dBrHXXRatio1 = BrHXXRatio - 1.0;
11478 dBrHXXRatio2 = 0.0;
11479 } else if (fstate == 4){
11480 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11481 dBrHXXRatio1 = BrHXXRatio - 1.0;
11482 dBrHXXRatio2 = 0.0;
11483 } else if (fstate == 5){
11484 BrHXXRatio = (myNPbase->BrHtautauRatio());
11485 dBrHXXRatio1 = BrHXXRatio - 1.0;
11486 dBrHXXRatio2 = 0.0;
11487 } else if (fstate == 6){
11488 BrHXXRatio = (myNPbase->BrHWWRatio());
11489 dBrHXXRatio1 = BrHXXRatio - 1.0;
11490 dBrHXXRatio2 = 0.0;
11491 } else if (fstate == 7){
11492 BrHXXRatio = (myNPbase->BrHZZRatio());
11493 dBrHXXRatio1 = BrHXXRatio - 1.0;
11494 dBrHXXRatio2 = 0.0;
11495 } else {
11496 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
11497 }
11498
11499 //-- Production x Decay:
11500 if ((this->getModel()).isModelLinearized()){
11501 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11502 } else if((this->getModel()).isModelNPquadratic()){
11503 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11504 } else {
11505 return weight*(muProd)*(BrHXXRatio);
11506 }
11507
11508}
11509
11510// -----------------------------------------------------------------------------
11511
11512//AG:STXS2024
11513STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11514: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11515{
11516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11517 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
11518
11519}
11520
11522{
11523 //-- Production:
11524 double weight = 1.0; //If normalized to the SM
11525 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
11526 double muProd1 = muProd -1.0;
11527 double muProd2 = 0.0;
11528
11529 //-- Decay:
11530 double BrHXXRatio = 1.0;
11531 double dBrHXXRatio1 = 0.0;
11532 double dBrHXXRatio2 = 0.0;
11533 if (fstate==0){
11534 // Use for Cross-section [pb] with no Higgs-boson decay
11535 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11536 } else if (fstate == 1){
11537 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11538 dBrHXXRatio1 = BrHXXRatio - 1.0;
11539 dBrHXXRatio2 = 0.0;
11540 } else if (fstate == 2){
11541 BrHXXRatio = (myNPbase->BrHgagaRatio());
11542 dBrHXXRatio1 = BrHXXRatio - 1.0;
11543 dBrHXXRatio2 = 0.0;
11544 } else if (fstate == 3){
11545 BrHXXRatio = (myNPbase->BrHbbRatio());
11546 dBrHXXRatio1 = BrHXXRatio - 1.0;
11547 dBrHXXRatio2 = 0.0;
11548 } else if (fstate == 4){
11549 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11550 dBrHXXRatio1 = BrHXXRatio - 1.0;
11551 dBrHXXRatio2 = 0.0;
11552 } else if (fstate == 5){
11553 BrHXXRatio = (myNPbase->BrHtautauRatio());
11554 dBrHXXRatio1 = BrHXXRatio - 1.0;
11555 dBrHXXRatio2 = 0.0;
11556 } else if (fstate == 6){
11557 BrHXXRatio = (myNPbase->BrHWWRatio());
11558 dBrHXXRatio1 = BrHXXRatio - 1.0;
11559 dBrHXXRatio2 = 0.0;
11560 } else if (fstate == 7){
11561 BrHXXRatio = (myNPbase->BrHZZRatio());
11562 dBrHXXRatio1 = BrHXXRatio - 1.0;
11563 dBrHXXRatio2 = 0.0;
11564 } else {
11565 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
11566 }
11567
11568 //-- Production x Decay:
11569 if ((this->getModel()).isModelLinearized()){
11570 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11571 } else if((this->getModel()).isModelNPquadratic()){
11572 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11573 } else {
11574 return weight*(muProd)*(BrHXXRatio);
11575 }
11576
11577}
11578
11579// -----------------------------------------------------------------------------
11580
11581//AG:STXS2024
11582STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11583: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11584{
11585 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11586 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
11587
11588}
11589
11591{
11592 //-- Production:
11593 double weight = 1.0; //If normalized to the SM
11594 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
11595 double muProd1 = muProd -1.0;
11596 double muProd2 = 0.0;
11597
11598 //-- Decay:
11599 double BrHXXRatio = 1.0;
11600 double dBrHXXRatio1 = 0.0;
11601 double dBrHXXRatio2 = 0.0;
11602 if (fstate==0){
11603 // Use for Cross-section [pb] with no Higgs-boson decay
11604 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11605 } else if (fstate == 1){
11606 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11607 dBrHXXRatio1 = BrHXXRatio - 1.0;
11608 dBrHXXRatio2 = 0.0;
11609 } else if (fstate == 2){
11610 BrHXXRatio = (myNPbase->BrHgagaRatio());
11611 dBrHXXRatio1 = BrHXXRatio - 1.0;
11612 dBrHXXRatio2 = 0.0;
11613 } else if (fstate == 3){
11614 BrHXXRatio = (myNPbase->BrHbbRatio());
11615 dBrHXXRatio1 = BrHXXRatio - 1.0;
11616 dBrHXXRatio2 = 0.0;
11617 } else if (fstate == 4){
11618 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11619 dBrHXXRatio1 = BrHXXRatio - 1.0;
11620 dBrHXXRatio2 = 0.0;
11621 } else if (fstate == 5){
11622 BrHXXRatio = (myNPbase->BrHtautauRatio());
11623 dBrHXXRatio1 = BrHXXRatio - 1.0;
11624 dBrHXXRatio2 = 0.0;
11625 } else if (fstate == 6){
11626 BrHXXRatio = (myNPbase->BrHWWRatio());
11627 dBrHXXRatio1 = BrHXXRatio - 1.0;
11628 dBrHXXRatio2 = 0.0;
11629 } else if (fstate == 7){
11630 BrHXXRatio = (myNPbase->BrHZZRatio());
11631 dBrHXXRatio1 = BrHXXRatio - 1.0;
11632 dBrHXXRatio2 = 0.0;
11633 } else {
11634 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
11635 }
11636
11637 //-- Production x Decay:
11638 if ((this->getModel()).isModelLinearized()){
11639 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11640 } else if((this->getModel()).isModelNPquadratic()){
11641 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11642 } else {
11643 return weight*(muProd)*(BrHXXRatio);
11644 }
11645
11646
11647}
11648
11649// -----------------------------------------------------------------------------
11650
11651//AG:STXS2024
11652STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11653: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11654{
11655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11656 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
11657
11658}
11659
11661{
11662 //-- Production:
11663 double weight = 1.0; //If normalized to the SM
11664 //Since adding bins, include partial weigths of SM_predictions
11665 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11666 double muProd = (0.0147*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
11669 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.0147+0.01683+0.00715+0.00126);
11670 double muProd1 = muProd-1.0;
11671 double muProd2 = 0.0;
11672
11673 //-- Decay:
11674 double BrHXXRatio = 1.0;
11675 double dBrHXXRatio1 = 0.0;
11676 double dBrHXXRatio2 = 0.0;
11677 if (fstate==0){
11678 weight = (0.0147+0.01683+0.00715+0.00126);
11679 } else if (fstate == 1){
11680 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11681 dBrHXXRatio1 = BrHXXRatio - 1.0;
11682 dBrHXXRatio2 = 0.0;
11683 } else if (fstate == 2){
11684 BrHXXRatio = (myNPbase->BrHgagaRatio());
11685 dBrHXXRatio1 = BrHXXRatio - 1.0;
11686 dBrHXXRatio2 = 0.0;
11687 } else if (fstate == 3){
11688 BrHXXRatio = (myNPbase->BrHbbRatio());
11689 dBrHXXRatio1 = BrHXXRatio - 1.0;
11690 dBrHXXRatio2 = 0.0;
11691 } else if (fstate == 4){
11692 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11693 dBrHXXRatio1 = BrHXXRatio - 1.0;
11694 dBrHXXRatio2 = 0.0;
11695 } else if (fstate == 5){
11696 BrHXXRatio = (myNPbase->BrHtautauRatio());
11697 dBrHXXRatio1 = BrHXXRatio - 1.0;
11698 dBrHXXRatio2 = 0.0;
11699 } else if (fstate == 6){
11700 BrHXXRatio = (myNPbase->BrHWWRatio());
11701 dBrHXXRatio1 = BrHXXRatio - 1.0;
11702 dBrHXXRatio2 = 0.0;
11703 } else if (fstate == 7){
11704 BrHXXRatio = (myNPbase->BrHZZRatio());
11705 dBrHXXRatio1 = BrHXXRatio - 1.0;
11706 dBrHXXRatio2 = 0.0;
11707 } else {
11708 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
11709 }
11710
11711 //-- Production x Decay:
11712 if ((this->getModel()).isModelLinearized()){
11713 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11714 } else if((this->getModel()).isModelNPquadratic()){
11715 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11716 } else {
11717 return weight*(muProd)*(BrHXXRatio);
11718 }
11719
11720
11721}
11722
11723
11724
11725
11726
11727
11728
11729
11730//VM:STXS2025
11731STXS12_qqHll::STXS12_qqHll(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11732: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11733{
11734 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11735 throw std::runtime_error("STXS12_qqHll called with a class whose parent is not NPbase");
11736
11737}
11738
11740{
11741 //-- Production:
11742 double weight = 1.0; //If normalized to the SM
11743 //Since adding bins, include partial weigths of SM_predictions
11744 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11745 double muProd = (0.19845*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s))
11750 )/(0.19845+0.0147+0.01683+0.00715+0.00126);
11751 double muProd1 = muProd - 1.0;
11752 double muProd2 = 0.0;
11753
11754 //-- Decay:
11755 double BrHXXRatio = 1.0;
11756 double dBrHXXRatio1 = 0.0;
11757 double dBrHXXRatio2 = 0.0;
11758 if (fstate==0){
11759 weight = (0.19845+0.0147+0.01683+0.00715+0.00126);
11760 } else if (fstate == 1){
11761 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11762 dBrHXXRatio1 = BrHXXRatio - 1.0;
11763 dBrHXXRatio2 = 0.0;
11764 } else if (fstate == 2){
11765 BrHXXRatio = (myNPbase->BrHgagaRatio());
11766 dBrHXXRatio1 = BrHXXRatio - 1.0;
11767 dBrHXXRatio2 = 0.0;
11768 } else if (fstate == 3){
11769 BrHXXRatio = (myNPbase->BrHbbRatio());
11770 dBrHXXRatio1 = BrHXXRatio - 1.0;
11771 dBrHXXRatio2 = 0.0;
11772 } else if (fstate == 4){
11773 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11774 dBrHXXRatio1 = BrHXXRatio - 1.0;
11775 dBrHXXRatio2 = 0.0;
11776 } else if (fstate == 5){
11777 BrHXXRatio = (myNPbase->BrHtautauRatio());
11778 dBrHXXRatio1 = BrHXXRatio - 1.0;
11779 dBrHXXRatio2 = 0.0;
11780 } else if (fstate == 6){
11781 BrHXXRatio = (myNPbase->BrHWWRatio());
11782 dBrHXXRatio1 = BrHXXRatio - 1.0;
11783 dBrHXXRatio2 = 0.0;
11784 } else if (fstate == 7){
11785 BrHXXRatio = (myNPbase->BrHZZRatio());
11786 dBrHXXRatio1 = BrHXXRatio - 1.0;
11787 dBrHXXRatio2 = 0.0;
11788 } else {
11789 throw std::runtime_error("STXS12_qqHll called with invalid argument for final state in fstate_i");
11790 }
11791
11792 //-- Production x Decay:
11793 if ((this->getModel()).isModelLinearized()){
11794 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11795 } else if((this->getModel()).isModelNPquadratic()){
11796 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11797 } else {
11798 return weight*(muProd)*(BrHXXRatio);
11799 }
11800
11801
11802}
11803
11804
11805
11806
11807// -----------------------------------------------------------------------------
11808
11809//AG:STXS2024
11810STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11811: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11812{
11813 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11814 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
11815
11816}
11817
11819{
11820 //-- Production:
11821 double weight = 1.0; //If normalized to the SM
11822 //Since adding bins, include partial weigths of SM_predictions
11823 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11824 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
11834 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934
11835 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11836
11837 double muProd1 = muProd - 1.0;
11838 double muProd2 = 0.0;
11839
11840 //-- Decay:
11841 double BrHXXRatio = 1.0;
11842 double dBrHXXRatio1 = 0.0;
11843 double dBrHXXRatio2 = 0.0;
11844 if (fstate==0){
11845 weight = (0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934
11846 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11847 } else if (fstate == 1){
11848 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11849 dBrHXXRatio1 = BrHXXRatio - 1.0;
11850 dBrHXXRatio2 = 0.0;
11851 } else if (fstate == 2){
11852 BrHXXRatio = (myNPbase->BrHgagaRatio());
11853 dBrHXXRatio1 = BrHXXRatio - 1.0;
11854 dBrHXXRatio2 = 0.0;
11855 } else if (fstate == 3){
11856 BrHXXRatio = (myNPbase->BrHbbRatio());
11857 dBrHXXRatio1 = BrHXXRatio - 1.0;
11858 dBrHXXRatio2 = 0.0;
11859 } else if (fstate == 4){
11860 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11861 dBrHXXRatio1 = BrHXXRatio - 1.0;
11862 dBrHXXRatio2 = 0.0;
11863 } else if (fstate == 5){
11864 BrHXXRatio = (myNPbase->BrHtautauRatio());
11865 dBrHXXRatio1 = BrHXXRatio - 1.0;
11866 dBrHXXRatio2 = 0.0;
11867 } else if (fstate == 6){
11868 BrHXXRatio = (myNPbase->BrHWWRatio());
11869 dBrHXXRatio1 = BrHXXRatio - 1.0;
11870 dBrHXXRatio2 = 0.0;
11871 } else if (fstate == 7){
11872 BrHXXRatio = (myNPbase->BrHZZRatio());
11873 dBrHXXRatio1 = BrHXXRatio - 1.0;
11874 dBrHXXRatio2 = 0.0;
11875 } else {
11876 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
11877 }
11878
11879 //-- Production x Decay:
11880 if ((this->getModel()).isModelLinearized()){
11881 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11882 } else if((this->getModel()).isModelNPquadratic()){
11883 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11884 } else {
11885 return weight*(muProd)*(BrHXXRatio);
11886 }
11887
11888
11889}
11890
11891// -----------------------------------------------------------------------------
11892
11893
11894
11895
11896
11897
11898//VM:STXS2025
11899STXS12_VHlep_pTV0_150::STXS12_VHlep_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //VM:added
11900: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11901{
11902 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11903 throw std::runtime_error("STXS12_VHlep_pTV0_150 called with a class whose parent is not NPbase");
11904
11905}
11906
11908{
11909 //-- Production:
11910 double weight = 1.0; //If normalized to the SM
11911 //Since adding bins, include partial weigths of SM_predictions
11912 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11913 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
11916 )
11917 /(0.71256 + 0.06739 + 0.07934);
11918 double muProd1 = muProd - 1.0;
11919 double muProd2 = 0.0;
11920
11921 //-- Decay:
11922 double BrHXXRatio = 1.0;
11923 double dBrHXXRatio1 = 0.0;
11924 double dBrHXXRatio2 = 0.0;
11925 if (fstate==0){
11926 weight = 1.0;
11927 } else if (fstate == 1){
11928 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11929 dBrHXXRatio1 = BrHXXRatio - 1.0;
11930 dBrHXXRatio2 = 0.0;
11931 } else if (fstate == 2){
11932 BrHXXRatio = (myNPbase->BrHgagaRatio());
11933 dBrHXXRatio1 = BrHXXRatio - 1.0;
11934 dBrHXXRatio2 = 0.0;
11935 } else if (fstate == 3){
11936 BrHXXRatio = (myNPbase->BrHbbRatio());
11937 dBrHXXRatio1 = BrHXXRatio - 1.0;
11938 dBrHXXRatio2 = 0.0;
11939 } else if (fstate == 4){
11940 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11941 dBrHXXRatio1 = BrHXXRatio - 1.0;
11942 dBrHXXRatio2 = 0.0;
11943 } else if (fstate == 5){
11944 BrHXXRatio = (myNPbase->BrHtautauRatio());
11945 dBrHXXRatio1 = BrHXXRatio - 1.0;
11946 dBrHXXRatio2 = 0.0;
11947 } else if (fstate == 6){
11948 BrHXXRatio = (myNPbase->BrHWWRatio());
11949 dBrHXXRatio1 = BrHXXRatio - 1.0;
11950 dBrHXXRatio2 = 0.0;
11951 } else if (fstate == 7){
11952 BrHXXRatio = (myNPbase->BrHZZRatio());
11953 dBrHXXRatio1 = BrHXXRatio - 1.0;
11954 dBrHXXRatio2 = 0.0;
11955 } else {
11956 throw std::runtime_error("STXS12_VHlep_pTV0_150 called with invalid argument for final state in fstate_i");
11957 }
11958
11959 //-- Production x Decay:
11960 if ((this->getModel()).isModelLinearized()){
11961 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11962 } else if((this->getModel()).isModelNPquadratic()){
11963 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11964 } else {
11965 return weight*(muProd)*(BrHXXRatio);
11966 }
11967
11968
11969}
11970
11971// -----------------------------------------------------------------------------
11972
11973
11974
11975
11976
11977//VM:STXS2024
11978STXS12_VHlep_pTV150_Inf::STXS12_VHlep_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //VM:added
11979: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11980{
11981 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11982 throw std::runtime_error("STXS12_VHlep_pTV150_Inf called with a class whose parent is not NPbase");
11983
11984}
11985
11987{
11988 //-- Production:
11989 double weight = 1.0; //If normalized to the SM
11990 //Since adding bins, include partial weigths of SM_predictions
11991 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11992 double muProd = (0.03943*myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
11999 /(0.03943 + 0.01127 + 0.00339 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
12000 double muProd1 = (muProd - 1.0);
12001 double muProd2 = 0.0;
12002
12003 //-- Decay:
12004 double BrHXXRatio = 1.0;
12005 double dBrHXXRatio1 = 0.0;
12006 double dBrHXXRatio2 = 0.0;
12007 if (fstate==0){
12008 weight = (0.03943 + 0.01127 + 0.00339 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
12009 } else if (fstate == 1){
12010 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12011 dBrHXXRatio1 = BrHXXRatio - 1.0;
12012 dBrHXXRatio2 = 0.0;
12013 } else if (fstate == 2){
12014 BrHXXRatio = (myNPbase->BrHgagaRatio());
12015 dBrHXXRatio1 = BrHXXRatio - 1.0;
12016 dBrHXXRatio2 = 0.0;
12017 } else if (fstate == 3){
12018 BrHXXRatio = (myNPbase->BrHbbRatio());
12019 dBrHXXRatio1 = BrHXXRatio - 1.0;
12020 dBrHXXRatio2 = 0.0;
12021 } else if (fstate == 4){
12022 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12023 dBrHXXRatio1 = BrHXXRatio - 1.0;
12024 dBrHXXRatio2 = 0.0;
12025 } else if (fstate == 5){
12026 BrHXXRatio = (myNPbase->BrHtautauRatio());
12027 dBrHXXRatio1 = BrHXXRatio - 1.0;
12028 dBrHXXRatio2 = 0.0;
12029 } else if (fstate == 6){
12030 BrHXXRatio = (myNPbase->BrHWWRatio());
12031 dBrHXXRatio1 = BrHXXRatio - 1.0;
12032 dBrHXXRatio2 = 0.0;
12033 } else if (fstate == 7){
12034 BrHXXRatio = (myNPbase->BrHZZRatio());
12035 dBrHXXRatio1 = BrHXXRatio - 1.0;
12036 dBrHXXRatio2 = 0.0;
12037 } else {
12038 throw std::runtime_error("STXS12_VHlep_pTV150_Inf called with invalid argument for final state in fstate_i");
12039 }
12040
12041 //-- Production x Decay:
12042 if ((this->getModel()).isModelLinearized()){
12043 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12044 } else if((this->getModel()).isModelNPquadratic()){
12045 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12046 } else {
12047 return weight*(muProd)*(BrHXXRatio);
12048 }
12049
12050
12051}
12052
12053// -----------------------------------------------------------------------------
12054
12055
12056
12057
12058
12059
12060//AG:STXS2024
12061STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12062: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12063{
12064 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12065 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
12066
12067}
12068
12070{
12071 //-- Production:
12072 double weight = 1.0; //If normalized to the SM
12073 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
12074 double muProd1 = muProd -1.0;
12075 double muProd2 = 0.0;
12076
12077 //-- Decay:
12078 double BrHXXRatio = 1.0;
12079 double dBrHXXRatio1 = 0.0;
12080 double dBrHXXRatio2 = 0.0;
12081 if (fstate==0){
12082 // Use for Cross-section [pb] with no Higgs-boson decay
12083 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12084 } else if (fstate == 1){
12085 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12086 dBrHXXRatio1 = BrHXXRatio - 1.0;
12087 dBrHXXRatio2 = 0.0;
12088 } else if (fstate == 2){
12089 BrHXXRatio = (myNPbase->BrHgagaRatio());
12090 dBrHXXRatio1 = BrHXXRatio - 1.0;
12091 dBrHXXRatio2 = 0.0;
12092 } else if (fstate == 3){
12093 BrHXXRatio = (myNPbase->BrHbbRatio());
12094 dBrHXXRatio1 = BrHXXRatio - 1.0;
12095 dBrHXXRatio2 = 0.0;
12096 } else if (fstate == 4){
12097 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12098 dBrHXXRatio1 = BrHXXRatio - 1.0;
12099 dBrHXXRatio2 = 0.0;
12100 } else {
12101 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
12102 }
12103
12104 //-- Production x Decay:
12105 if ((this->getModel()).isModelLinearized()){
12106 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12107 } else if((this->getModel()).isModelNPquadratic()){
12108 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12109 } else {
12110 return weight*(muProd)*(BrHXXRatio);
12111 }
12112
12113
12114}
12115
12116// -----------------------------------------------------------------------------
12117
12118//AG:STXS2024
12119STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12120: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12121{
12122 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12123 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
12124
12125}
12126
12128{
12129 //-- Production:
12130 double weight = 1.0; //If normalized to the SM
12131 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
12132 double muProd1 = muProd -1.0;
12133 double muProd2 = 0.0;
12134
12135 //-- Decay:
12136 double BrHXXRatio = 1.0;
12137 double dBrHXXRatio1 = 0.0;
12138 double dBrHXXRatio2 = 0.0;
12139 if (fstate==0){
12140 // Use for Cross-section [pb] with no Higgs-boson decay
12141 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12142 } else if (fstate == 1){
12143 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12144 dBrHXXRatio1 = BrHXXRatio - 1.0;
12145 dBrHXXRatio2 = 0.0;
12146 } else if (fstate == 2){
12147 BrHXXRatio = (myNPbase->BrHgagaRatio());
12148 dBrHXXRatio1 = BrHXXRatio - 1.0;
12149 dBrHXXRatio2 = 0.0;
12150 } else if (fstate == 3){
12151 BrHXXRatio = (myNPbase->BrHbbRatio());
12152 dBrHXXRatio1 = BrHXXRatio - 1.0;
12153 dBrHXXRatio2 = 0.0;
12154 } else if (fstate == 4){
12155 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12156 dBrHXXRatio1 = BrHXXRatio - 1.0;
12157 dBrHXXRatio2 = 0.0;
12158 } else {
12159 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
12160 }
12161
12162 //-- Production x Decay:
12163 if ((this->getModel()).isModelLinearized()){
12164 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12165 } else if((this->getModel()).isModelNPquadratic()){
12166 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12167 } else {
12168 return weight*(muProd)*(BrHXXRatio);
12169 }
12170
12171}
12172
12173// -----------------------------------------------------------------------------
12174
12175//AG:STXS2024
12176STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12177: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12178{
12179 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12180 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
12181
12182}
12183
12185{
12186 //-- Production:
12187 double weight = 1.0; //If normalized to the SM
12188 //Since adding bins, include partial weigths of SM_predictions
12189 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
12190 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
12191 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
12192 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
12193 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
12194 double muProd2 = 0.0;
12195
12196 //-- Decay:
12197 double BrHXXRatio = 1.0;
12198 double dBrHXXRatio1 = 0.0;
12199 double dBrHXXRatio2 = 0.0;
12200 if (fstate==0){
12201 // Use for Cross-section [pb] with no Higgs-boson decay
12202 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12203 } else if (fstate == 1){
12204 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12205 dBrHXXRatio1 = BrHXXRatio - 1.0;
12206 dBrHXXRatio2 = 0.0;
12207 } else if (fstate == 2){
12208 BrHXXRatio = (myNPbase->BrHgagaRatio());
12209 dBrHXXRatio1 = BrHXXRatio - 1.0;
12210 dBrHXXRatio2 = 0.0;
12211 } else if (fstate == 3){
12212 BrHXXRatio = (myNPbase->BrHbbRatio());
12213 dBrHXXRatio1 = BrHXXRatio - 1.0;
12214 dBrHXXRatio2 = 0.0;
12215 } else if (fstate == 4){
12216 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12217 dBrHXXRatio1 = BrHXXRatio - 1.0;
12218 dBrHXXRatio2 = 0.0;
12219 } else {
12220 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
12221 }
12222
12223 //-- Production x Decay:
12224 if ((this->getModel()).isModelLinearized()){
12225 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12226 } else if((this->getModel()).isModelNPquadratic()){
12227 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12228 } else {
12229 return weight*(muProd)*(BrHXXRatio);
12230 }
12231
12232}
12233
12234// -----------------------------------------------------------------------------
12235
12236//AG:STXS2024
12237STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12238: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12239{
12240 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12241 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
12242
12243}
12244
12246{
12247 //-- Production:
12248 double weight = 1.0; //If normalized to the SM
12249 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
12250 double muProd1 = muProd -1.0;
12251 double muProd2 = 0.0;
12252
12253 //-- Decay:
12254 double BrHXXRatio = 1.0;
12255 double dBrHXXRatio1 = 0.0;
12256 double dBrHXXRatio2 = 0.0;
12257 if (fstate==0){
12258 // Use for Cross-section [pb] with no Higgs-boson decay
12259 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12260 } else if (fstate == 1){
12261 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12262 dBrHXXRatio1 = BrHXXRatio - 1.0;
12263 dBrHXXRatio2 = 0.0;
12264 } else if (fstate == 2){
12265 BrHXXRatio = (myNPbase->BrHgagaRatio());
12266 dBrHXXRatio1 = BrHXXRatio - 1.0;
12267 dBrHXXRatio2 = 0.0;
12268 } else if (fstate == 3){
12269 BrHXXRatio = (myNPbase->BrHbbRatio());
12270 dBrHXXRatio1 = BrHXXRatio - 1.0;
12271 dBrHXXRatio2 = 0.0;
12272 } else if (fstate == 4){
12273 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12274 dBrHXXRatio1 = BrHXXRatio - 1.0;
12275 dBrHXXRatio2 = 0.0;
12276 } else {
12277 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
12278 }
12279
12280 //-- Production x Decay:
12281 if ((this->getModel()).isModelLinearized()){
12282 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12283 } else if((this->getModel()).isModelNPquadratic()){
12284 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12285 } else {
12286 return weight*(muProd)*(BrHXXRatio);
12287 }
12288
12289}
12290
12291// -----------------------------------------------------------------------------
12292
12293//AG:STXS2024
12294STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12295: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12296{
12297 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12298 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
12299
12300}
12301
12303{
12304 //-- Production:
12305 double weight = 1.0; //If normalized to the SM
12306 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
12307 double muProd1 = muProd -1.0;
12308 double muProd2 = 0.0;
12309
12310 //-- Decay:
12311 double BrHXXRatio = 1.0;
12312 double dBrHXXRatio1 = 0.0;
12313 double dBrHXXRatio2 = 0.0;
12314 if (fstate==0){
12315 // Use for Cross-section [pb] with no Higgs-boson decay
12316 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12317 } else if (fstate == 1){
12318 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12319 dBrHXXRatio1 = BrHXXRatio - 1.0;
12320 dBrHXXRatio2 = 0.0;
12321 } else if (fstate == 2){
12322 BrHXXRatio = (myNPbase->BrHgagaRatio());
12323 dBrHXXRatio1 = BrHXXRatio - 1.0;
12324 dBrHXXRatio2 = 0.0;
12325 } else if (fstate == 3){
12326 BrHXXRatio = (myNPbase->BrHbbRatio());
12327 dBrHXXRatio1 = BrHXXRatio - 1.0;
12328 dBrHXXRatio2 = 0.0;
12329 } else if (fstate == 4){
12330 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12331 dBrHXXRatio1 = BrHXXRatio - 1.0;
12332 dBrHXXRatio2 = 0.0;
12333 } else {
12334 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
12335 }
12336
12337 //-- Production x Decay:
12338 if ((this->getModel()).isModelLinearized()){
12339 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12340 } else if((this->getModel()).isModelNPquadratic()){
12341 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12342 } else {
12343 return weight*(muProd)*(BrHXXRatio);
12344 }
12345
12346}
12347
12348// -----------------------------------------------------------------------------
12349
12350STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12351: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12352{
12353 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12354 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
12355
12356}
12357
12359{
12360 //VM: Modified to take the thinner bins
12361 //-- Production:
12362 double weight = 1.0; //If normalized to the SM
12363 //double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
12364 double muProd = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s))
12366 )/(0.01903+0.00538);
12367 double muProd1 = muProd -1.0;
12368 double muProd2 = 0.0;
12369
12370 //-- Decay:
12371 double BrHXXRatio = 1.0;
12372 double dBrHXXRatio1 = 0.0;
12373 double dBrHXXRatio2 = 0.0;
12374 if (fstate==0){
12375 // Use for Cross-section [pb] with no Higgs-boson decay
12376 weight = (0.01903+0.00538); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12377 } else if (fstate == 1){
12378 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12379 dBrHXXRatio1 = BrHXXRatio - 1.0;
12380 dBrHXXRatio2 = 0.0;
12381 } else if (fstate == 2){
12382 BrHXXRatio = (myNPbase->BrHgagaRatio());
12383 dBrHXXRatio1 = BrHXXRatio - 1.0;
12384 dBrHXXRatio2 = 0.0;
12385 } else if (fstate == 3){
12386 BrHXXRatio = (myNPbase->BrHbbRatio());
12387 dBrHXXRatio1 = BrHXXRatio - 1.0;
12388 dBrHXXRatio2 = 0.0;
12389 } else if (fstate == 4){
12390 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12391 dBrHXXRatio1 = BrHXXRatio - 1.0;
12392 dBrHXXRatio2 = 0.0;
12393 } else {
12394 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
12395 }
12396
12397 //-- Production x Decay:
12398 if ((this->getModel()).isModelLinearized()){
12399 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12400 } else if((this->getModel()).isModelNPquadratic()){
12401 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12402 } else {
12403 return weight*(muProd)*(BrHXXRatio);
12404 }
12405
12406
12407}
12408
12409// -----------------------------------------------------------------------------
12410
12411//AG:STXS2024
12412STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12413: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12414{
12415 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12416 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
12417
12418}
12419
12421{
12422 //-- Production:
12423 double weight = 1.0; //If normalized to the SM
12424 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
12425 double muProd1 = muProd -1.0;
12426 double muProd2 = 0.0;
12427
12428 //-- Decay:
12429 double BrHXXRatio = 1.0;
12430 double dBrHXXRatio1 = 0.0;
12431 double dBrHXXRatio2 = 0.0;
12432 if (fstate==0){
12433 // Use for Cross-section [pb] with no Higgs-boson decay
12434 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12435 } else if (fstate == 1){
12436 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12437 dBrHXXRatio1 = BrHXXRatio - 1.0;
12438 dBrHXXRatio2 = 0.0;
12439 } else if (fstate == 2){
12440 BrHXXRatio = (myNPbase->BrHgagaRatio());
12441 dBrHXXRatio1 = BrHXXRatio - 1.0;
12442 dBrHXXRatio2 = 0.0;
12443 } else if (fstate == 3){
12444 BrHXXRatio = (myNPbase->BrHbbRatio());
12445 dBrHXXRatio1 = BrHXXRatio - 1.0;
12446 dBrHXXRatio2 = 0.0;
12447 } else if (fstate == 4){
12448 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12449 dBrHXXRatio1 = BrHXXRatio - 1.0;
12450 dBrHXXRatio2 = 0.0;
12451 } else if (fstate == 5){
12452 BrHXXRatio = (myNPbase->BrHtautauRatio());
12453 dBrHXXRatio1 = BrHXXRatio - 1.0;
12454 dBrHXXRatio2 = 0.0;
12455 } else {
12456 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
12457 }
12458
12459 //-- Production x Decay:
12460 if ((this->getModel()).isModelLinearized()){
12461 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12462 } else if((this->getModel()).isModelNPquadratic()){
12463 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12464 } else {
12465 return weight*(muProd)*(BrHXXRatio);
12466 }
12467
12468}
12469// -----------------------------------------------------------------------------
12470
12471//AG:STXS2024
12472STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12473: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12474{
12475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12476 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
12477
12478}
12479
12481{
12482 //-- Production:
12483 double weight = 1.0; //If normalized to the SM
12484 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
12485 double muProd1 = muProd -1.0;
12486 double muProd2 = 0.0;
12487
12488 //-- Decay:
12489 double BrHXXRatio = 1.0;
12490 double dBrHXXRatio1 = 0.0;
12491 double dBrHXXRatio2 = 0.0;
12492 if (fstate==0){
12493 // Use for Cross-section [pb] with no Higgs-boson decay
12494 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12495 } else if (fstate == 1){
12496 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12497 dBrHXXRatio1 = BrHXXRatio - 1.0;
12498 dBrHXXRatio2 = 0.0;
12499 } else if (fstate == 2){
12500 BrHXXRatio = (myNPbase->BrHgagaRatio());
12501 dBrHXXRatio1 = BrHXXRatio - 1.0;
12502 dBrHXXRatio2 = 0.0;
12503 } else if (fstate == 3){
12504 BrHXXRatio = (myNPbase->BrHbbRatio());
12505 dBrHXXRatio1 = BrHXXRatio - 1.0;
12506 dBrHXXRatio2 = 0.0;
12507 } else if (fstate == 4){
12508 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12509 dBrHXXRatio1 = BrHXXRatio - 1.0;
12510 dBrHXXRatio2 = 0.0;
12511 } else if (fstate == 5){
12512 BrHXXRatio = (myNPbase->BrHtautauRatio());
12513 dBrHXXRatio1 = BrHXXRatio - 1.0;
12514 dBrHXXRatio2 = 0.0;
12515 } else {
12516 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
12517 }
12518
12519 //-- Production x Decay:
12520 if ((this->getModel()).isModelLinearized()){
12521 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12522 } else if((this->getModel()).isModelNPquadratic()){
12523 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12524 } else {
12525 return weight*(muProd)*(BrHXXRatio);
12526 }
12527
12528}
12529
12530// -----------------------------------------------------------------------------
12531
12532//AG:STXS2024
12533STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12534: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12535{
12536 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12537 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
12538
12539}
12540
12542{
12543 //-- Production:
12544 double weight = 1.0; //If normalized to the SM
12545 //Since adding bins, include partial weigths of SM_predictions
12546 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
12547 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
12548 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
12549 double muProd1 = muProd - 1.0;
12550 double muProd2 = 0.0;
12551
12552 //-- Decay:
12553 double BrHXXRatio = 1.0;
12554 double dBrHXXRatio1 = 0.0;
12555 double dBrHXXRatio2 = 0.0;
12556 if (fstate==0){
12557 // Use for Cross-section [pb] with no Higgs-boson decay
12558 weight = (0.01903+0.00538); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12559 } else if (fstate == 1){
12560 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12561 dBrHXXRatio1 = BrHXXRatio - 1.0;
12562 dBrHXXRatio2 = 0.0;
12563 } else if (fstate == 2){
12564 BrHXXRatio = (myNPbase->BrHgagaRatio());
12565 dBrHXXRatio1 = BrHXXRatio - 1.0;
12566 dBrHXXRatio2 = 0.0;
12567 } else if (fstate == 3){
12568 BrHXXRatio = (myNPbase->BrHbbRatio());
12569 dBrHXXRatio1 = BrHXXRatio - 1.0;
12570 dBrHXXRatio2 = 0.0;
12571 } else if (fstate == 4){
12572 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12573 dBrHXXRatio1 = BrHXXRatio - 1.0;
12574 dBrHXXRatio2 = 0.0;
12575 } else if (fstate == 5){
12576 BrHXXRatio = (myNPbase->BrHtautauRatio());
12577 dBrHXXRatio1 = BrHXXRatio - 1.0;
12578 dBrHXXRatio2 = 0.0;
12579 } else {
12580 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
12581 }
12582
12583 //-- Production x Decay:
12584 if ((this->getModel()).isModelLinearized()){
12585 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12586 } else if((this->getModel()).isModelNPquadratic()){
12587 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12588 } else {
12589 return weight*(muProd)*(BrHXXRatio);
12590 }
12591
12592}
12593
12594// -----------------------------------------------------------------------------
12595
12596//AG:STXS2024
12597STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12598: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12599{
12600 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12601 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
12602
12603}
12604
12606{
12607 //-- Production:
12608 double weight = 1.0; //If normalized to the SM
12609 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12610 //Since adding bins, include partial weigths (SM_predictions)
12611 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
12616 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
12617 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
12618 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
12619 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
12620 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
12621 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
12622 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
12623 double muProd2 = 0.0;
12624
12625 //-- Decay:
12626 double BrHXXRatio = 1.0;
12627 double dBrHXXRatio1 = 0.0;
12628 double dBrHXXRatio2 = 0.0;
12629 if (fstate==0){
12630 weight = (0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
12631 } else if (fstate == 1){
12632 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12633 dBrHXXRatio1 = BrHXXRatio - 1.0;
12634 dBrHXXRatio2 = 0.0;
12635 } else if (fstate == 2){
12636 BrHXXRatio = (myNPbase->BrHgagaRatio());
12637 dBrHXXRatio1 = BrHXXRatio - 1.0;
12638 dBrHXXRatio2 = 0.0;
12639 } else if (fstate == 3){
12640 BrHXXRatio = (myNPbase->BrHbbRatio());
12641 dBrHXXRatio1 = BrHXXRatio - 1.0;
12642 dBrHXXRatio2 = 0.0;
12643 } else if (fstate == 4){
12644 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12645 dBrHXXRatio1 = BrHXXRatio - 1.0;
12646 dBrHXXRatio2 = 0.0;
12647 } else if (fstate == 5){
12648 BrHXXRatio = (myNPbase->BrHtautauRatio());
12649 dBrHXXRatio1 = BrHXXRatio - 1.0;
12650 dBrHXXRatio2 = 0.0;
12651 } else if (fstate == 6){
12652 BrHXXRatio = (myNPbase->BrHWWRatio());
12653 dBrHXXRatio1 = BrHXXRatio - 1.0;
12654 dBrHXXRatio2 = 0.0;
12655 } else if (fstate == 7){
12656 BrHXXRatio = (myNPbase->BrHZZRatio());
12657 dBrHXXRatio1 = BrHXXRatio - 1.0;
12658 dBrHXXRatio2 = 0.0;
12659 } else {
12660 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
12661 }
12662
12663 //-- Production x Decay:
12664 if ((this->getModel()).isModelLinearized()){
12665 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12666 } else if((this->getModel()).isModelNPquadratic()){
12667 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12668 } else {
12669 return weight*(muProd)*(BrHXXRatio);
12670 }
12671
12672}
12673
12674// -----------------------------------------------------------------------------
12675
12676//AG:STXS2024
12677STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
12678: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12679{
12680 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12681 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
12682
12683}
12684
12685double STXS12_tH::computeThValue() //AG:modified
12686{
12687 //-- Production:
12688 double weight = 1.0; //If normalized to the SM
12689 double muProd = myNPbase->STXS12_tH(sqrt_s);
12690 double muProd1 = muProd -1.0;
12691 double muProd2 = 0.0;
12692
12693 //-- Decay:
12694 double BrHXXRatio = 1.0;
12695 double dBrHXXRatio1 = 0.0;
12696 double dBrHXXRatio2 = 0.0;
12697 if (fstate==0){
12698 // Use for Cross-section [pb] with no Higgs-boson decay
12699 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12700 } else if (fstate == 1){
12701 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12702 dBrHXXRatio1 = BrHXXRatio - 1.0;
12703 dBrHXXRatio2 = 0.0;
12704 } else if (fstate == 2){
12705 BrHXXRatio = (myNPbase->BrHgagaRatio());
12706 dBrHXXRatio1 = BrHXXRatio - 1.0;
12707 dBrHXXRatio2 = 0.0;
12708 } else if (fstate == 3){
12709 BrHXXRatio = (myNPbase->BrHbbRatio());
12710 dBrHXXRatio1 = BrHXXRatio - 1.0;
12711 dBrHXXRatio2 = 0.0;
12712 } else if (fstate == 4){
12713 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12714 dBrHXXRatio1 = BrHXXRatio - 1.0;
12715 dBrHXXRatio2 = 0.0;
12716 } else if (fstate == 5){
12717 BrHXXRatio = (myNPbase->BrHtautauRatio());
12718 dBrHXXRatio1 = BrHXXRatio - 1.0;
12719 dBrHXXRatio2 = 0.0;
12720 } else if (fstate == 6){
12721 BrHXXRatio = (myNPbase->BrHWWRatio());
12722 dBrHXXRatio1 = BrHXXRatio - 1.0;
12723 dBrHXXRatio2 = 0.0;
12724 } else if (fstate == 7){
12725 BrHXXRatio = (myNPbase->BrHZZRatio());
12726 dBrHXXRatio1 = BrHXXRatio - 1.0;
12727 dBrHXXRatio2 = 0.0;
12728 } else {
12729 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
12730 }
12731
12732 //-- Production x Decay:
12733 if ((this->getModel()).isModelLinearized()){
12734 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12735 } else if((this->getModel()).isModelNPquadratic()){
12736 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12737 } else {
12738 return weight*(muProd)*(BrHXXRatio);
12739 }
12740
12741
12742}
12743
12744
12745
12746// -----------------------------------------------------------------------------
12747
12748
12749
12750//VM:STXS2025
12751STXS12_ttH_tH::STXS12_ttH_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
12752: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12753{
12754 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12755 throw std::runtime_error("STXS12_ttH_tH called with a class whose parent is not NPbase");
12756
12757}
12758
12760{
12761 //-- Production:
12762 double weight = 1.0; //If normalized to the SM
12763 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
12764 //Since adding bins, include partial weigths (SM_predictions)
12765 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
12771 + 0.08207*myNPbase->STXS12_tH(sqrt_s)
12772 ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 + 0.08207);
12773 double muProd1 = ( muProd - 1.0 );
12774 double muProd2 = 0.0;
12775
12776 //-- Decay:
12777 double BrHXXRatio = 1.0;
12778 double dBrHXXRatio1 = 0.0;
12779 double dBrHXXRatio2 = 0.0;
12780 if (fstate==0){
12781 weight = (0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 + 0.08207);
12782 } else if (fstate == 1){
12783 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
12784 dBrHXXRatio1 = BrHXXRatio - 1.0;
12785 dBrHXXRatio2 = 0.0;
12786 } else if (fstate == 2){
12787 BrHXXRatio = (myNPbase->BrHgagaRatio());
12788 dBrHXXRatio1 = BrHXXRatio - 1.0;
12789 dBrHXXRatio2 = 0.0;
12790 } else if (fstate == 3){
12791 BrHXXRatio = (myNPbase->BrHbbRatio());
12792 dBrHXXRatio1 = BrHXXRatio - 1.0;
12793 dBrHXXRatio2 = 0.0;
12794 } else if (fstate == 4){
12795 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
12796 dBrHXXRatio1 = BrHXXRatio - 1.0;
12797 dBrHXXRatio2 = 0.0;
12798 } else if (fstate == 5){
12799 BrHXXRatio = (myNPbase->BrHtautauRatio());
12800 dBrHXXRatio1 = BrHXXRatio - 1.0;
12801 dBrHXXRatio2 = 0.0;
12802 } else if (fstate == 6){
12803 BrHXXRatio = (myNPbase->BrHWWRatio());
12804 dBrHXXRatio1 = BrHXXRatio - 1.0;
12805 dBrHXXRatio2 = 0.0;
12806 } else if (fstate == 7){
12807 BrHXXRatio = (myNPbase->BrHZZRatio());
12808 dBrHXXRatio1 = BrHXXRatio - 1.0;
12809 dBrHXXRatio2 = 0.0;
12810 } else {
12811 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
12812 }
12813
12814 //-- Production x Decay:
12815 if ((this->getModel()).isModelLinearized()){
12816 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12817 } else if((this->getModel()).isModelNPquadratic()){
12818 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12819 } else {
12820 return weight*(muProd)*(BrHXXRatio);
12821 }
12822
12823}
12824
12825// -----------------------------------------------------------------------------
12826
12827
12828//-----------------------------------------------------------------------------------------
12829//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
12830//-----------------------------------------------------------------------------------------
12831
12832
12833muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12834: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12835{
12836 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12837 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
12838}
12839
12841{
12842 return myNPbase->muTHUggHgaga(sqrt_s);
12843}
12844
12845
12846muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12847: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12848{
12849 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12850 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
12851}
12852
12854{
12855 return myNPbase->muTHUVBFHgaga(sqrt_s);
12856}
12857
12858muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12859: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12860{
12861 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12862 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
12863}
12864
12866{
12867 return myNPbase->muTHUZHgaga(sqrt_s);
12868}
12869
12870muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12871: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12872{
12873 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12874 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
12875}
12876
12878{
12879 return myNPbase->muTHUWHgaga(sqrt_s);
12880}
12881
12882muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12883: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12884{
12885 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12886 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
12887}
12888
12890{
12891 return myNPbase->muTHUVHgaga(sqrt_s);
12892}
12893
12894muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
12895: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12896{
12897 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12898 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
12899}
12900
12902{
12903 return myNPbase->muTHUttHgaga(sqrt_s);
12904}
12905
12906muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
12907: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12908{
12909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12910 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
12911}
12912
12914{
12915 return myNPbase->muTHUggHZga(sqrt_s);
12916}
12917
12918muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
12919: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12920{
12921 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12922 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
12923}
12924
12926{
12927 return (myNPbase->muTHUggHZgamumu(sqrt_s));
12928}
12929
12930muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
12931: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12932{
12933 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12934 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
12935}
12936
12938{
12939
12940 return myNPbase->muTHUVBFHZga(sqrt_s);
12941}
12942
12943muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
12944: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12945{
12946 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12947 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
12948}
12949
12951{
12952 return myNPbase->muTHUZHZga(sqrt_s);
12953}
12954
12955muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
12956: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12957{
12958 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12959 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
12960}
12961
12963{
12964 return myNPbase->muTHUWHZga(sqrt_s);
12965}
12966
12967muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
12968: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12969{
12970 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12971 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
12972}
12973
12975{
12976 return myNPbase->muTHUVHZga(sqrt_s);
12977}
12978
12979muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
12980: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12981{
12982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12983 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
12984}
12985
12987{
12988 return myNPbase->muTHUttHZga(sqrt_s);
12989}
12990
12991muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
12992: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12993{
12994 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12995 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
12996}
12997
12999{
13000 return myNPbase->muTHUggHZZ(sqrt_s);
13001}
13002
13003muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
13004: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13005{
13006 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13007 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
13008}
13009
13011{
13012 return myNPbase->muTHUVBFHZZ(sqrt_s);
13013}
13014
13015muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
13016: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13017{
13018 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13019 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
13020}
13021
13023{
13024 return myNPbase->muTHUZHZZ(sqrt_s);
13025}
13026
13027muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
13028: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13029{
13030 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13031 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
13032}
13033
13035{
13036 return myNPbase->muTHUWHZZ(sqrt_s);
13037}
13038
13039muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
13040: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13041{
13042 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13043 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
13044}
13045
13047{
13048 return myNPbase->muTHUVHZZ(sqrt_s);
13049}
13050
13051muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
13052: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13053{
13054 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13055 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
13056}
13057
13059{
13060 return myNPbase->muTHUttHZZ(sqrt_s);
13061}
13062
13063muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13064: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13065{
13066 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13067 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
13068}
13069
13071{
13072 return myNPbase->muTHUggHZZ4l(sqrt_s);
13073}
13074
13075muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
13076: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13077{
13078 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13079 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
13080}
13081
13083{
13084 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
13085}
13086
13087muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13088: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13089{
13090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13091 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
13092}
13093
13095{
13096 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
13097}
13098
13099muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13100: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13101{
13102 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13103 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
13104}
13105
13107{
13108 return myNPbase->muTHUZHZZ4l(sqrt_s);
13109}
13110
13111muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13112: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13113{
13114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13115 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
13116}
13117
13119{
13120 return myNPbase->muTHUWHZZ4l(sqrt_s);
13121}
13122
13123muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13125{
13126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13127 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
13128}
13129
13131{
13132 return myNPbase->muTHUVHZZ4l(sqrt_s);
13133}
13134
13135muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
13136: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13137{
13138 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13139 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
13140}
13141
13143{
13144 return myNPbase->muTHUttHZZ4l(sqrt_s);
13145}
13146
13147muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
13148: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13149{
13150 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13151 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
13152}
13153
13155{
13156 return myNPbase->muTHUggHWW(sqrt_s);
13157}
13158
13159muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
13160: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13161{
13162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13163 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
13164}
13165
13167{
13168 return myNPbase->muTHUVBFHWW(sqrt_s);
13169}
13170
13171muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
13172: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13173{
13174 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13175 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
13176}
13177
13179{
13180 return myNPbase->muTHUZHWW(sqrt_s);
13181}
13182
13183muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
13184: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13185{
13186 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13187 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
13188}
13189
13191{
13192 return myNPbase->muTHUWHWW(sqrt_s);
13193}
13194
13195muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
13196: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13197{
13198 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13199 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
13200}
13201
13203{
13204 return myNPbase->muTHUVHWW(sqrt_s);
13205}
13206
13207muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
13208: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13209{
13210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13211 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
13212}
13213
13215{
13216 return myNPbase->muTHUttHWW(sqrt_s);
13217}
13218
13219muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13220: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13221{
13222 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13223 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
13224}
13225
13227{
13229}
13230
13231muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13232: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13233{
13234 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13235 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
13236}
13237
13239{
13241}
13242
13243muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13244: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13245{
13246 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13247 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
13248}
13249
13251{
13252 return myNPbase->muTHUZHWW2l2v(sqrt_s);
13253}
13254
13255muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13256: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13257{
13258 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13259 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
13260}
13261
13263{
13264 return myNPbase->muTHUWHWW2l2v(sqrt_s);
13265}
13266
13267muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13268: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13269{
13270 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13271 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
13272}
13273
13275{
13276 return myNPbase->muTHUVHWW2l2v(sqrt_s);
13277}
13278
13279muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
13280: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13281{
13282 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13283 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
13284}
13285
13287{
13289}
13290
13291muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13292: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13293{
13294 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13295 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
13296}
13297
13299{
13300 return myNPbase->muTHUggHmumu(sqrt_s);
13301}
13302
13303muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13304: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13305{
13306 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13307 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
13308}
13309
13311{
13312 return myNPbase->muTHUVBFHmumu(sqrt_s);
13313}
13314
13315muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13316: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13317{
13318 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13319 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
13320}
13321
13323{
13324 return myNPbase->muTHUZHmumu(sqrt_s);
13325}
13326
13327muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13328: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13329{
13330 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13331 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
13332}
13333
13335{
13336 return myNPbase->muTHUWHmumu(sqrt_s);
13337}
13338
13339muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13340: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13341{
13342 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13343 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
13344}
13345
13347{
13348 return myNPbase->muTHUVHmumu(sqrt_s);
13349}
13350
13351muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
13352: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13353{
13354 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13355 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
13356}
13357
13359{
13360 return myNPbase->muTHUttHmumu(sqrt_s);
13361}
13362
13363muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13364: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13365{
13366 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13367 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
13368}
13369
13371{
13373}
13374
13375muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13376: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13377{
13378 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13379 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
13380}
13381
13383{
13385}
13386
13387muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13388: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13389{
13390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13391 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
13392}
13393
13395{
13396 return myNPbase->muTHUZHtautau(sqrt_s);
13397}
13398
13399muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13400: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13401{
13402 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13403 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
13404}
13405
13407{
13408 return myNPbase->muTHUWHtautau(sqrt_s);
13409}
13410
13411muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13412: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13413{
13414 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13415 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
13416}
13417
13419{
13420 return myNPbase->muTHUVHtautau(sqrt_s);
13421}
13422
13423muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
13424: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13425{
13426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13427 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
13428}
13429
13431{
13433}
13434
13435muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
13436: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13437{
13438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13439 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
13440}
13441
13443{
13444 return myNPbase->muTHUggHbb(sqrt_s);
13445}
13446
13447muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
13448: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13449{
13450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13451 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
13452}
13453
13455{
13456 return myNPbase->muTHUVBFHbb(sqrt_s);
13457}
13458
13459muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
13460: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13461{
13462 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13463 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
13464}
13465
13467{
13468 return myNPbase->muTHUZHbb(sqrt_s);
13469}
13470
13471muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
13472: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13473{
13474 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13475 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
13476}
13477
13479{
13480 return myNPbase->muTHUWHbb(sqrt_s);
13481}
13482
13483muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
13484: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13485{
13486 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13487 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
13488}
13489
13491{
13492 return myNPbase->muTHUVHbb(sqrt_s);
13493}
13494
13495muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
13496: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13497{
13498 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13499 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
13500}
13501
13503{
13504 return myNPbase->muTHUttHbb(sqrt_s);
13505}
13506
13507
13508muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
13509: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13510{
13511 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13512 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
13513}
13514
13516{
13517
13518 return (myNPbase->muTHUVBFBRinv(sqrt_s));
13519
13520}
13521
13522muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
13523: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13524{
13525 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13526 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
13527}
13528
13530{
13531
13532 return (myNPbase->muTHUVBFHinv(sqrt_s));
13533
13534}
13535
13536
13537muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
13538: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13539{
13540 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13541 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
13542}
13543
13545{
13546
13547 return (myNPbase->muTHUVHBRinv(sqrt_s));
13548
13549}
13550
13551muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
13552: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13553{
13554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
13555 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
13556}
13557
13559{
13560 return (myNPbase->muTHUVHinv(sqrt_s));
13561}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoZmumuga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1872
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1796
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4075
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3680
virtual const double cbminuscc() const
Definition: NPbase.h:2869
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:3055
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4356
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:2053
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4446
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2494
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1176
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3971
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:3019
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2945
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2602
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:3115
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4086
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1659
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3460
virtual const double cVpluscb() const
Definition: NPbase.h:2851
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:2057
double C1HZZ
Definition: NPbase.h:5713
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3980
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1397
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1776
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1151
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4147
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4239
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4065
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3506
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1976
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1432
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:1127
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2244
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4179
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1537
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1226
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3555
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1573
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2162
virtual const double muttHgagaZeeboost(const double sqrt_s) const
The ratio in the , channel channel in the current model and in the Standard Model.
Definition: NPbase.h:1596
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1743
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1675
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1844
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2957
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3709
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1812
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4338
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3857
virtual const double ccminusctau() const
Definition: NPbase.h:2887
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2969
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4224
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3585
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1808
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4473
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1723
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1949
virtual const double cgaplusct() const
Definition: NPbase.h:2833
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:3120
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2929
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:2039
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1260
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1800
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3497
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4455
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:4169
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2234
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1477
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4188
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:3130
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1972
virtual const double delta2sBRH3(const double C1prod, const double C1Hxx) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for in the...
Definition: NPbase.h:2752
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2909
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2949
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2953
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3866
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4129
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1832
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2182
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4248
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4284
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3023
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3535
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4311
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1699
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2999
virtual const double cgplusct() const
Definition: NPbase.h:2824
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1864
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3820
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2925
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1489
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:3103
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4098
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1756
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1764
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4392
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1663
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1784
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:2071
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1295
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3953
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3833
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4275
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3793
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2395
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2359
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2337
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1601
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1904
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1346
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3893
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1619
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3689
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2254
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:2030
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3875
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:2044
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4347
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4383
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3748
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3699
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:3107
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3729
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2990
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1908
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:3135
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2681
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1967
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1667
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:2048
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3479
virtual const double C1eeZBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1780
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1788
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1772
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1711
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4500
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:2026
double C1Htautau
Definition: NPbase.h:5712
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1999
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2917
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3575
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1695
double C1Hbb
Definition: NPbase.h:5712
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2089
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1918
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3719
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1271
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1927
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4016
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:2008
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:3015
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3784
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2109
double C1Hgg
Definition: NPbase.h:5713
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2224
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3594
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1671
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:3091
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1836
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1719
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3039
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1502
virtual const double C1eeWBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1680
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1309
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3884
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2099
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2731
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2921
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2611
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3450
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1804
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1189
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1780
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1868
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1884
double C1Hcc
Definition: NPbase.h:5712
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:2075
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4120
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3671
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1792
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4111
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4043
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3766
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3802
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1852
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2905
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:2021
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:3011
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:2017
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1607
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3035
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4007
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1359
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3921
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2327
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1963
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1643
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2815
virtual const double C1eettH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1830
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2632
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3603
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1647
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3841
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3631
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2701
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4518
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2204
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4025
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1727
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1513
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1525
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3515
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4054
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2284
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1880
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4197
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1201
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3488
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2788
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:3051
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3998
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4401
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:3140
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2192
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4034
virtual const double delta2sH3(const double C1) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for an obse...
Definition: NPbase.h:2743
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:3083
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2978
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1760
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4206
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4257
double C1Hgaga
Definition: NPbase.h:5713
virtual const double C1eeZH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1630
virtual const double cbminusctau() const
Definition: NPbase.h:2878
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2663
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1421
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2172
double C1Hss
Definition: NPbase.h:5712
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2404
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1164
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2994
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1735
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2797
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3043
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4138
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1214
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3989
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2119
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2129
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2692
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1613
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1888
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1768
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2965
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:1116
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3545
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1585
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3565
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2986
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3757
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:2012
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1856
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:3071
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2142
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3932
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4293
double C1HZga
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
Definition: NPbase.h:5713
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2264
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3775
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2548
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:3125
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1876
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2152
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2900
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1892
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4464
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2974
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1655
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:3095
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2913
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1816
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1703
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:2035
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1249
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4536
virtual const double C1eeHvv(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
Definition: NPbase.cpp:1730
double C1HWW
Definition: NPbase.h:5713
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1707
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2711
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1840
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1824
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3944
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1691
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2654
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:3003
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4320
virtual const double muVBFpVH_HZga(const double sqrt_s) const
Definition: NPbase.h:1687
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3651
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4419
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2721
double C1Hmumu
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
Definition: NPbase.h:5712
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3849
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2317
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1848
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:3111
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1385
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1409
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1931
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3470
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:4158
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4428
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1465
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:3145
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3525
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3911
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1549
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4329
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1860
virtual const double muggHpttHptHpbbH_HZga(const double sqrt_s) const
Definition: NPbase.h:1683
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2641
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2503
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1679
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:3079
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2297
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1639
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4215
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3962
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2806
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2933
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2214
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3027
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2274
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1321
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1945
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1820
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3739
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:3063
virtual const double cgminuscga() const
Definition: NPbase.h:2842
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3438
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1922
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2961
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4266
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:3087
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1282
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1912
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3622
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3641
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:1139
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1634
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2672
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:1105
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:2003
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4527
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1748
virtual const double cVplusctau() const
Definition: NPbase.h:2860
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:3031
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3811
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1238
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1936
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:3075
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1752
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4410
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1940
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1896
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1739
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2937
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1443
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4482
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1372
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:3099
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:3059
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4365
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1333
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3661
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2982
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4437
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1828
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1651
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1900
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:3067
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4491
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3613
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2307
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:3047
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1731
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3902
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:3007
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1561
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4302
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2941
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH60_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
STXS12_qqHll(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFpVH_HZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeHvvss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const double Pol_em
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_HZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmm(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHgagaZeeboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the channel in the current model.
const NPbase * myNPbase
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase